diff --git a/Cargo.lock b/Cargo.lock
index 6adb7b2697..660966e311 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1031,6 +1031,7 @@ dependencies = [
  "ckb-store",
  "ckb-sync",
  "ckb-tx-pool",
+ "ckb-types",
  "ckb-verification",
  "ckb-verification-traits",
 ]
diff --git a/Makefile b/Makefile
index 966a1090a8..7882a0524b 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 .DEFAULT_GOAL:=help
 SHELL = /bin/sh
 MOLC    := moleculec
-MOLC_VERSION := 0.8.0
+MOLC_VERSION := 0.7.5
 VERBOSE := $(if ${CI},--verbose,)
 CLIPPY_OPTS := -D warnings -D clippy::clone_on_ref_ptr -D clippy::redundant_clone -D clippy::enum_glob_use -D clippy::fallible_impl_from \
 	-A clippy::mutable_key_type -A clippy::upper_case_acronyms -A clippy::needless_return
diff --git a/benches/benches/benchmarks/overall.rs b/benches/benches/benchmarks/overall.rs
index 921bf85804..103cab0893 100644
--- a/benches/benches/benchmarks/overall.rs
+++ b/benches/benches/benchmarks/overall.rs
@@ -34,11 +34,11 @@ const SIZES: &[usize] = &[2usize];
 
 fn block_assembler_config() -> BlockAssemblerConfig {
     let (_, _, secp_script) = secp_cell();
-    let args = JsonBytes::from_bytes(secp_script.args().into());
+    let args = JsonBytes::from_bytes(secp_script.args().unpack());
     let hash_type = ScriptHashType::try_from(secp_script.hash_type()).expect("checked data");
 
     BlockAssemblerConfig {
-        code_hash: secp_script.code_hash().into(),
+        code_hash: secp_script.code_hash().unpack(),
         hash_type: hash_type.into(),
         args,
         message: Default::default(),
@@ -92,21 +92,21 @@ pub fn setup_chain(txs_size: usize) -> (Shared, ChainController) {
         .map(|i| {
             let data = Bytes::from(i.to_le_bytes().to_vec());
             let output = CellOutput::new_builder()
-                .capacity(capacity_bytes!(50_000))
+                .capacity(capacity_bytes!(50_000).pack())
                 .lock(secp_script.clone())
                 .build();
             TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(output.clone())
                 .output(output)
-                .output_data(&data)
-                .output_data(&data)
+                .output_data(data.pack())
+                .output_data(data.pack())
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .dao(dao)
         .transaction(tx)
         .transactions(transactions)
@@ -207,7 +207,7 @@ fn bench(c: &mut Criterion) {
                             let raw_header = raw_block.header().raw();
                             let header = Header::new_builder()
                                 .raw(raw_header)
-                                .nonce(random::<u128>())
+                                .nonce(random::<u128>().pack())
                                 .build();
                             let block = raw_block.as_builder().header(header).build().into_view();
 
diff --git a/benches/benches/benchmarks/resolve.rs b/benches/benches/benchmarks/resolve.rs
index a250781623..37ec9d11c3 100644
--- a/benches/benches/benchmarks/resolve.rs
+++ b/benches/benches/benchmarks/resolve.rs
@@ -33,29 +33,32 @@ const DEFAULT_CODE_HASH: H256 =
 
 fn script() -> Script {
     Script::new_builder()
-        .code_hash(DEFAULT_CODE_HASH)
-        .args(Bytes::from(PUBKEY_HASH.as_bytes()))
-        .hash_type(ScriptHashType::Type)
+        .code_hash(DEFAULT_CODE_HASH.pack())
+        .args(Bytes::from(PUBKEY_HASH.as_bytes()).pack())
+        .hash_type(ScriptHashType::Type.into())
         .build()
 }
 
 fn cell_dep(genesis: &BlockView) -> CellDep {
     let tx_hash = genesis.transaction(1).unwrap().hash();
-    let out_point = OutPoint::new_builder().tx_hash(tx_hash).index(0u32).build();
+    let out_point = OutPoint::new_builder()
+        .tx_hash(tx_hash)
+        .index(0u32.pack())
+        .build();
 
     CellDep::new_builder()
         .out_point(out_point)
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build()
 }
 
 fn block_assembler_config() -> BlockAssemblerConfig {
     let secp_script = script();
-    let args = JsonBytes::from_bytes(secp_script.args().into());
+    let args = JsonBytes::from_bytes(secp_script.args().unpack());
     let hash_type = ScriptHashType::try_from(secp_script.hash_type()).expect("checked data");
 
     BlockAssemblerConfig {
-        code_hash: secp_script.code_hash().into(),
+        code_hash: secp_script.code_hash().unpack(),
         hash_type: hash_type.into(),
         args,
         message: Default::default(),
diff --git a/benches/benches/benchmarks/util.rs b/benches/benches/benchmarks/util.rs
index 9a5afc336d..a9f64d0a50 100644
--- a/benches/benches/benchmarks/util.rs
+++ b/benches/benches/benchmarks/util.rs
@@ -49,18 +49,18 @@ pub fn new_always_success_chain(txs_size: usize, chains_num: usize) -> Chains {
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(
                     CellOutput::new_builder()
-                        .capacity(capacity_bytes!(50_000))
+                        .capacity(capacity_bytes!(50_000).pack())
                         .lock(always_success_script.clone())
                         .build(),
                 )
-                .output_data(data)
+                .output_data(data.pack())
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
         .dao(dao)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .transaction(tx)
         .transactions(transactions)
         .build();
@@ -92,7 +92,7 @@ pub fn create_always_success_tx() -> TransactionView {
         .witness(script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
         .output(always_success_cell.clone())
-        .output_data(always_success_cell_data)
+        .output_data(always_success_cell_data.pack())
         .build()
 }
 
@@ -110,11 +110,11 @@ pub fn create_always_success_cellbase(shared: &Shared, parent: &HeaderView) -> T
         builder
             .output(
                 CellOutput::new_builder()
-                    .capacity(capacity)
+                    .capacity(capacity.pack())
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -185,11 +185,11 @@ pub fn gen_always_success_block(
         .transactions(transactions)
         .proposals(proposals)
         .parent_hash(p_block.hash())
-        .number(number)
-        .timestamp(timestamp)
-        .compact_target(epoch.compact_target())
-        .epoch(epoch.number_with_fraction(number))
-        .nonce(random::<u128>())
+        .number(number.pack())
+        .timestamp(timestamp.pack())
+        .compact_target(epoch.compact_target().pack())
+        .epoch(epoch.number_with_fraction(number).pack())
+        .nonce(random::<u128>().pack())
         .dao(dao)
         .build();
 
@@ -208,7 +208,7 @@ lazy_static! {
         let data: Bytes = raw_data.to_vec().into();
 
         let cell = CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build();
         (cell, data)
     };
@@ -219,13 +219,13 @@ lazy_static! {
         let data: Bytes = raw_data.to_vec().into();
 
         let cell = CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build();
 
         let script = Script::new_builder()
             .code_hash(CellOutput::calc_data_hash(&data))
-            .args(Bytes::from(PUBKEY_HASH.as_bytes()))
-            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(PUBKEY_HASH.as_bytes()).pack())
+            .hash_type(ScriptHashType::Data.into())
             .build();
 
         (cell, data, script)
@@ -244,7 +244,7 @@ pub fn create_secp_tx() -> TransactionView {
     let (ref secp_data_cell, ref secp_data_cell_data) = secp_data_cell();
     let (ref secp_cell, ref secp_cell_data, ref script) = secp_cell();
     let outputs = vec![secp_data_cell.clone(), secp_cell.clone()];
-    let outputs_data = vec![secp_data_cell_data.into(), secp_cell_data.into()];
+    let outputs_data = vec![secp_data_cell_data.pack(), secp_cell_data.pack()];
     TransactionBuilder::default()
         .witness(script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
@@ -263,21 +263,21 @@ pub fn new_secp_chain(txs_size: usize, chains_num: usize) -> Chains {
         .map(|i| {
             let data = Bytes::from(i.to_le_bytes().to_vec());
             let output = CellOutput::new_builder()
-                .capacity(capacity_bytes!(50_000))
+                .capacity(capacity_bytes!(50_000).pack())
                 .lock(secp_script.clone())
                 .build();
             TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(output.clone())
                 .output(output)
-                .output_data(&data)
-                .output_data(&data)
+                .output_data(data.pack())
+                .output_data(data.pack())
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .dao(dao)
         .transaction(tx)
         .transactions(transactions)
@@ -318,11 +318,11 @@ pub fn create_secp_cellbase(shared: &Shared, parent: &HeaderView) -> Transaction
         builder
             .output(
                 CellOutput::new_builder()
-                    .capacity(capacity)
+                    .capacity(capacity.pack())
                     .lock(secp_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -395,11 +395,11 @@ pub fn gen_secp_block(
         .transactions(transactions)
         .proposals(proposals)
         .parent_hash(p_block.hash())
-        .number(number)
-        .timestamp(timestamp)
-        .compact_target(epoch.compact_target())
-        .epoch(epoch.number_with_fraction(number))
-        .nonce(random::<u128>())
+        .number(number.pack())
+        .timestamp(timestamp.pack())
+        .compact_target(epoch.compact_target().pack())
+        .epoch(epoch.number_with_fraction(number).pack())
+        .nonce(random::<u128>().pack())
         .dao(dao)
         .build();
 
@@ -412,11 +412,11 @@ fn create_transaction(parent_hash: &Byte32, lock: Script, dep: OutPoint) -> Tran
     TransactionBuilder::default()
         .output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50_000))
+                .capacity(capacity_bytes!(50_000).pack())
                 .lock(lock)
                 .build(),
         )
-        .output_data(data)
+        .output_data(data.pack())
         .input(CellInput::new(OutPoint::new(parent_hash.to_owned(), 0), 0))
         .cell_dep(CellDep::new_builder().out_point(dep).build())
         .build()
@@ -431,7 +431,7 @@ pub fn create_2out_transaction(
 
     let cell_inputs = inputs.into_iter().map(|pts| CellInput::new(pts, 0));
     let cell_output = CellOutput::new_builder()
-        .capacity(capacity_bytes!(50_000))
+        .capacity(capacity_bytes!(50_000).pack())
         .lock(lock)
         .build();
 
@@ -440,15 +440,15 @@ pub fn create_2out_transaction(
     let raw = TransactionBuilder::default()
         .output(cell_output.clone())
         .output(cell_output)
-        .output_data(&data)
-        .output_data(&data)
+        .output_data(data.pack())
+        .output_data(data.pack())
         .inputs(cell_inputs)
         .cell_deps(cell_deps)
         .build();
 
     let privkey: Privkey = PRIVKEY.into();
     let witness: WitnessArgs = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])))
+        .lock(Some(Bytes::from(vec![0u8; 65])).pack())
         .build();
     let witness_len: u64 = witness.as_bytes().len() as u64;
     let non_sig_witnesses = vec![Bytes::new(); inputs_count - 1];
@@ -470,10 +470,10 @@ pub fn create_2out_transaction(
         .expect("sign tx")
         .serialize()
         .into();
-    let witness = witness.as_builder().lock(Some(sig)).build();
+    let witness = witness.as_builder().lock(Some(sig).pack()).build();
 
-    let mut witnesses = vec![witness.as_bytes().into()];
-    witnesses.extend(non_sig_witnesses.into_iter().map(|w| w.into()));
+    let mut witnesses = vec![witness.as_bytes().pack()];
+    witnesses.extend(non_sig_witnesses.into_iter().map(|w| w.pack()));
 
     raw.as_advanced_builder().set_witnesses(witnesses).build()
 }
diff --git a/block-filter/src/filter.rs b/block-filter/src/filter.rs
index 1d744ee04b..65fd9fca40 100644
--- a/block-filter/src/filter.rs
+++ b/block-filter/src/filter.rs
@@ -6,6 +6,7 @@ use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
     core::HeaderView,
     packed::{Byte32, CellOutput, OutPoint},
+    prelude::*,
     utilities::{build_filter_data, FilterDataProvider},
 };
 
@@ -25,7 +26,7 @@ impl<'a> FilterDataProvider for WrappedChainDB<'a> {
     fn cell(&self, out_point: &OutPoint) -> Option<CellOutput> {
         self.inner
             .get_transaction(&out_point.tx_hash())
-            .and_then(|(tx, _)| tx.outputs().get(out_point.index().into()))
+            .and_then(|(tx, _)| tx.outputs().get(out_point.index().unpack()))
     }
 }
 
@@ -157,7 +158,7 @@ impl BlockFilter {
         db_transaction
             .insert_block_filter(
                 &header.hash(),
-                &filter_data.as_slice().into(),
+                &filter_data.pack(),
                 &parent_block_filter_hash,
             )
             .expect("insert_block_filter should be ok");
diff --git a/chain/src/init_load_unverified.rs b/chain/src/init_load_unverified.rs
index 11283fe17c..30b0247cdb 100644
--- a/chain/src/init_load_unverified.rs
+++ b/chain/src/init_load_unverified.rs
@@ -9,7 +9,7 @@ use ckb_stop_handler::has_received_stop_signal;
 use ckb_store::ChainStore;
 use ckb_types::core::{BlockNumber, BlockView};
 use ckb_types::packed;
-use ckb_types::prelude::{Entity, FromSliceShouldBeOk, Reader};
+use ckb_types::prelude::{Entity, FromSliceShouldBeOk, Pack, Reader};
 use std::cmp;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
@@ -34,7 +34,7 @@ impl InitLoadUnverified {
     }
 
     fn find_unverified_block_hashes(&self, check_unverified_number: u64) -> Vec<packed::Byte32> {
-        let pack_number: packed::Uint64 = check_unverified_number.into();
+        let pack_number: packed::Uint64 = check_unverified_number.pack();
         let prefix = pack_number.as_slice();
 
         // If a block has `COLUMN_NUMBER_HASH` but not `BlockExt`,
diff --git a/chain/src/lib.rs b/chain/src/lib.rs
index 7d4cae3d55..34b61ef562 100644
--- a/chain/src/lib.rs
+++ b/chain/src/lib.rs
@@ -28,6 +28,7 @@ pub mod verify;
 pub use chain_controller::ChainController;
 use ckb_logger::{error, info};
 use ckb_store::{ChainDB, ChainStore};
+use ckb_types::prelude::{Pack, Unpack};
 use ckb_types::{BlockNumberAndHash, H256};
 pub use init::start_chain_services;
 
@@ -88,11 +89,11 @@ impl From<LonelyBlock> for LonelyBlockHash {
             switch,
             verify_callback,
         } = val;
-        let block_hash_h256: H256 = block.hash().into();
+        let block_hash_h256: H256 = block.hash().unpack();
         let block_number: BlockNumber = block.number();
-        let parent_hash_h256: H256 = block.parent_hash().into();
-        let block_hash = block_hash_h256.into();
-        let parent_hash = parent_hash_h256.into();
+        let parent_hash_h256: H256 = block.parent_hash().unpack();
+        let block_hash = block_hash_h256.pack();
+        let parent_hash = parent_hash_h256.pack();
 
         let epoch_number: EpochNumber = block.epoch().number();
 
diff --git a/chain/src/tests/basic.rs b/chain/src/tests/basic.rs
index 0b3a0fe886..b1d2947a82 100644
--- a/chain/src/tests/basic.rs
+++ b/chain/src/tests/basic.rs
@@ -10,6 +10,7 @@ use ckb_test_chain_utils::{
     create_transaction, create_transaction_with_out_point, dao_data, MockChain, MockStore,
 };
 use ckb_types::core::error::OutPointError;
+use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
@@ -21,7 +22,6 @@ use ckb_types::{
     utilities::{compact_to_difficulty, difficulty_to_compact},
     U256,
 };
-use ckb_types::{packed, prelude::*};
 use ckb_verification_traits::Switch;
 use std::sync::Arc;
 
@@ -65,11 +65,11 @@ fn process_genesis_block() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000))
+                .capacity(capacity_bytes!(100_000_000).pack())
                 .build();
             100
         ])
-        .outputs_data(vec![packed::Bytes::default(); 100])
+        .outputs_data(vec![Bytes::new(); 100].pack())
         .build();
     let always_success_tx = create_always_success_tx();
 
@@ -78,7 +78,7 @@ fn process_genesis_block() {
     let genesis_block = BlockBuilder::default()
         .transaction(tx.clone())
         .transaction(always_success_tx.clone())
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .dao(dao.clone())
         .build();
 
@@ -104,7 +104,7 @@ fn process_genesis_block() {
         .transaction(tx)
         .transaction(always_success_tx)
         // Difficulty is changed here
-        .compact_target(difficulty_to_compact(U256::from(999u64)))
+        .compact_target(difficulty_to_compact(U256::from(999u64)).pack())
         .dao(dao)
         .build();
     let result = chain_controller.blocking_process_block(Arc::new(different_genesis_block));
@@ -119,13 +119,11 @@ fn test_genesis_transaction_spend() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000))
+                .capacity(capacity_bytes!(100_000_000).pack())
                 .build();
             100
         ])
-        .outputs_data(Into::<packed::BytesVec>::into(
-            vec![Bytes::new(); 100].as_slice(),
-        ))
+        .outputs_data(vec![Bytes::new(); 100].pack())
         .build();
     let always_success_tx = create_always_success_tx();
 
@@ -138,7 +136,7 @@ fn test_genesis_transaction_spend() {
     let genesis_block = BlockBuilder::default()
         .transaction(tx)
         .transaction(always_success_tx)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .dao(dao)
         .build();
 
@@ -431,14 +429,12 @@ fn test_genesis_transaction_fetch() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000))
+                .capacity(capacity_bytes!(100_000_000).pack())
                 .lock(Script::default())
                 .build();
             100
         ])
-        .outputs_data(Into::<packed::BytesVec>::into(
-            vec![Bytes::new(); 100].as_slice(),
-        ))
+        .outputs_data(vec![Bytes::new(); 100].pack())
         .build();
 
     let dao = genesis_dao_data(vec![&tx]).unwrap();
@@ -446,7 +442,7 @@ fn test_genesis_transaction_fetch() {
     let genesis_block = BlockBuilder::default()
         .dao(dao)
         .transaction(tx)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .build();
 
     let consensus = ConsensusBuilder::default()
@@ -578,10 +574,10 @@ fn prepare_context_chain(
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
-            .timestamp(parent.timestamp() + timestep)
-            .compact_target(epoch.compact_target())
+            .number((parent.number() + 1).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .timestamp((parent.timestamp() + timestep).pack())
+            .compact_target(epoch.compact_target().pack())
             .transactions(transactions)
             .dao(dao)
             .build();
@@ -618,10 +614,10 @@ fn prepare_context_chain(
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
             .uncles(uncles)
-            .number(parent.number() + 1)
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
-            .timestamp(parent.timestamp() + timestep)
-            .compact_target(epoch.compact_target())
+            .number((parent.number() + 1).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .timestamp((parent.timestamp() + timestep).pack())
+            .compact_target(epoch.compact_target().pack())
             .transactions(transactions)
             .dao(dao)
             .build();
@@ -644,7 +640,7 @@ fn test_epoch_hash_rate_dampening() {
         .build();
     let dao = genesis_dao_data(vec![&cellbase]).unwrap();
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .transaction(cellbase)
         .dao(dao)
         .build();
@@ -737,7 +733,7 @@ fn test_orphan_rate_estimation_overflow() {
     let dao = genesis_dao_data(vec![&cellbase]).unwrap();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .transaction(cellbase)
         .dao(dao)
         .build();
@@ -791,7 +787,7 @@ fn test_next_epoch_ext() {
         .build();
     let dao = genesis_dao_data(vec![&cellbase]).unwrap();
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .transaction(cellbase)
         .dao(dao)
         .build();
diff --git a/chain/src/tests/block_assembler.rs b/chain/src/tests/block_assembler.rs
index bc3627cbd3..caf0eb84ca 100644
--- a/chain/src/tests/block_assembler.rs
+++ b/chain/src/tests/block_assembler.rs
@@ -14,7 +14,7 @@ use ckb_types::{
         TransactionBuilder, TransactionView,
     },
     h256,
-    packed::{self, Block, CellInput, CellOutput, CellOutputBuilder, CellbaseWitness, OutPoint},
+    packed::{Block, CellInput, CellOutput, CellOutputBuilder, CellbaseWitness, OutPoint},
     prelude::*,
 };
 use ckb_verification::{BlockVerifier, HeaderVerifier};
@@ -104,18 +104,18 @@ fn gen_block(parent_header: &HeaderView, nonce: u128, epoch: &EpochExt) -> Block
     let dao = genesis_dao_data(vec![&cellbase]).unwrap();
     let header = HeaderBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(parent_header.timestamp() + 10)
-        .number(number)
-        .epoch(epoch.number_with_fraction(number))
-        .compact_target(epoch.compact_target())
-        .nonce(nonce)
+        .timestamp((parent_header.timestamp() + 10).pack())
+        .number(number.pack())
+        .epoch(epoch.number_with_fraction(number).pack())
+        .compact_target(epoch.compact_target().pack())
+        .nonce(nonce.pack())
         .dao(dao)
         .build();
 
     BlockBuilder::default()
         .header(header)
         .transaction(cellbase)
-        .proposal([1; 10])
+        .proposal([1; 10].pack())
         .build_unchecked()
 }
 
@@ -124,10 +124,10 @@ fn create_cellbase(number: BlockNumber, epoch: &EpochExt) -> TransactionView {
         .input(CellInput::new_cellbase_input(number))
         .output(
             CellOutput::new_builder()
-                .capacity(epoch.block_reward(number).unwrap())
+                .capacity(epoch.block_reward(number).unwrap().pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build()
 }
 
@@ -234,7 +234,7 @@ fn test_prepare_uncles() {
             .unwrap()
             .unwrap()
     }
-    assert_eq!(block_template.uncles[0].hash, block0_0.hash().into());
+    assert_eq!(block_template.uncles[0].hash, block0_0.hash().unpack());
 
     let epoch = shared
         .consensus()
@@ -258,7 +258,7 @@ fn test_prepare_uncles() {
             .unwrap()
     }
     // block number 4, epoch 0, uncles should retained
-    assert_eq!(block_template.uncles[0].hash, block0_0.hash().into());
+    assert_eq!(block_template.uncles[0].hash, block0_0.hash().unpack());
 
     let epoch = shared
         .consensus()
@@ -383,12 +383,12 @@ fn build_tx(parent_tx: &TransactionView, inputs: &[u32], outputs_len: usize) ->
             (0..outputs_len)
                 .map(|_| {
                     CellOutputBuilder::default()
-                        .capacity(per_output_capacity)
+                        .capacity(per_output_capacity.pack())
                         .build()
                 })
                 .collect::<Vec<CellOutput>>(),
         )
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
         .build()
 }
 
diff --git a/chain/src/tests/cell.rs b/chain/src/tests/cell.rs
index fc9438c542..3d9c2fd5b9 100644
--- a/chain/src/tests/cell.rs
+++ b/chain/src/tests/cell.rs
@@ -35,8 +35,12 @@ pub(crate) fn create_cellbase(
         builder.build()
     } else {
         builder
-            .output(CellOutputBuilder::default().capacity(capacity).build())
-            .output_data(Bytes::new())
+            .output(
+                CellOutputBuilder::default()
+                    .capacity(capacity.pack())
+                    .build(),
+            )
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -62,10 +66,10 @@ pub(crate) fn gen_block(
 
     let block = BlockBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(parent_header.timestamp() + 20_000)
-        .number(number)
-        .compact_target(epoch.compact_target())
-        .epoch(epoch.number_with_fraction(number))
+        .timestamp((parent_header.timestamp() + 20_000).pack())
+        .number(number.pack())
+        .compact_target(epoch.compact_target().pack())
+        .epoch(epoch.number_with_fraction(number).pack())
         .transactions(txs)
         .build();
 
@@ -79,16 +83,16 @@ pub(crate) fn create_transaction(parent: &TransactionView, index: u32) -> Transa
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .into();
+        .unpack();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
                 .build(),
         )
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build()
 }
 
@@ -100,11 +104,11 @@ fn test_block_cells_update() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -112,7 +116,7 @@ fn test_block_cells_update() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/delay_verify.rs b/chain/src/tests/delay_verify.rs
index b30e9b79b2..bd36fa558f 100644
--- a/chain/src/tests/delay_verify.rs
+++ b/chain/src/tests/delay_verify.rs
@@ -6,6 +6,7 @@ use ckb_test_chain_utils::{
     create_transaction_with_out_point, dao_data, MockChain, MockStore,
 };
 use ckb_types::core::error::OutPointError;
+use ckb_types::prelude::*;
 use ckb_types::{core::BlockBuilder, packed::OutPoint};
 use ckb_verification_traits::Switch;
 use std::sync::Arc;
@@ -286,9 +287,9 @@ fn test_full_dead_transaction() {
 
     let block = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .compact_target(compact_target - 1)
+        .number((parent.number() + 1).pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .compact_target((compact_target - 1).pack())
         .dao(dao)
         .transaction(cellbase_tx)
         .build();
@@ -326,9 +327,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number(parent.number() + 1)
-                    .epoch(epoch.number_with_fraction(parent.number() + 1))
-                    .compact_target(compact_target - 1)
+                    .number((parent.number() + 1).pack())
+                    .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                    .compact_target((compact_target - 1).pack())
                     .dao(dao)
                     .transactions(transactions)
                     .proposals(vec![tx1.proposal_short_id()])
@@ -347,9 +348,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number(parent.number() + 1)
-                    .epoch(epoch.number_with_fraction(parent.number() + 1))
-                    .compact_target(compact_target - 1)
+                    .number((parent.number() + 1).pack())
+                    .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                    .compact_target((compact_target - 1).pack())
                     .dao(dao)
                     .transactions(transactions)
                     .build()
@@ -364,9 +365,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number(parent.number() + 1)
-                    .epoch(epoch.number_with_fraction(parent.number() + 1))
-                    .compact_target(compact_target - 1)
+                    .number((parent.number() + 1).pack())
+                    .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                    .compact_target((compact_target - 1).pack())
                     .dao(dao)
                     .transactions(transactions)
                     .build()
@@ -406,9 +407,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number(parent.number() + 1)
-                        .epoch(epoch.number_with_fraction(parent.number() + 1))
-                        .compact_target(compact_target - 1)
+                        .number((parent.number() + 1).pack())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                        .compact_target((compact_target - 1).pack())
                         .dao(dao)
                         .transactions(transactions)
                         .proposals(vec![tx2.proposal_short_id(), tx3.proposal_short_id()])
@@ -428,9 +429,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number(parent.number() + 1)
-                        .epoch(epoch.number_with_fraction(parent.number() + 1))
-                        .compact_target(compact_target - 1)
+                        .number((parent.number() + 1).pack())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                        .compact_target((compact_target - 1).pack())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -447,9 +448,9 @@ fn test_full_dead_transaction() {
 
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number(parent.number() + 1)
-                        .epoch(epoch.number_with_fraction(parent.number() + 1))
-                        .compact_target(compact_target - 1)
+                        .number((parent.number() + 1).pack())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                        .compact_target((compact_target - 1).pack())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -478,9 +479,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number(parent.number() + 1)
-                        .epoch(epoch.number_with_fraction(parent.number() + 1))
-                        .compact_target(compact_target - 1)
+                        .number((parent.number() + 1).pack())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                        .compact_target((compact_target - 1).pack())
                         .dao(dao)
                         .proposals(vec![tx2.proposal_short_id(), tx3.proposal_short_id()])
                         .transactions(transactions)
@@ -500,9 +501,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number(parent.number() + 1)
-                        .epoch(epoch.number_with_fraction(parent.number() + 1))
-                        .compact_target(compact_target - 1)
+                        .number((parent.number() + 1).pack())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                        .compact_target((compact_target - 1).pack())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -519,9 +520,9 @@ fn test_full_dead_transaction() {
 
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number(parent.number() + 1)
-                        .epoch(epoch.number_with_fraction(parent.number() + 1))
-                        .compact_target(compact_target - 1)
+                        .number((parent.number() + 1).pack())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+                        .compact_target((compact_target - 1).pack())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
diff --git a/chain/src/tests/dep_cell.rs b/chain/src/tests/dep_cell.rs
index ff3572e692..64e3fbe7d4 100644
--- a/chain/src/tests/dep_cell.rs
+++ b/chain/src/tests/dep_cell.rs
@@ -31,7 +31,7 @@ pub(crate) fn build_tx(
         .iter()
         .map(|index| {
             let output = inputs.0.output(*index as usize).expect("output index");
-            let cap: Capacity = output.capacity().into();
+            let cap: Capacity = output.capacity().unpack();
             cap
         })
         .try_fold(Capacity::zero(), Capacity::safe_add)
@@ -45,13 +45,13 @@ pub(crate) fn build_tx(
             (0..outputs_len)
                 .map(|_| {
                     CellOutputBuilder::default()
-                        .capacity(per_output_capacity)
+                        .capacity(per_output_capacity.pack())
                         .lock(always_success_script.clone())
                         .build()
                 })
                 .collect::<Vec<CellOutput>>(),
         )
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
         .cell_deps(cell_deps.1.iter().map(|index| {
             CellDep::new_builder()
                 .out_point(OutPoint::new(cell_deps.0.hash(), *index))
@@ -79,18 +79,18 @@ fn test_package_txs_with_deps() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -98,7 +98,7 @@ fn test_package_txs_with_deps() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
@@ -211,25 +211,25 @@ fn test_package_txs_with_deps_unstable_sort() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
-        .output_data(Bytes::new())
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -237,7 +237,7 @@ fn test_package_txs_with_deps_unstable_sort() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
@@ -355,25 +355,25 @@ fn test_package_txs_with_deps2() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
-        .output_data(Bytes::new())
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -381,7 +381,7 @@ fn test_package_txs_with_deps2() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
@@ -492,18 +492,18 @@ fn test_package_txs_with_deps_priority() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -511,7 +511,7 @@ fn test_package_txs_with_deps_priority() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/find_fork.rs b/chain/src/tests/find_fork.rs
index 6c9fdfb6b7..2c39cfd0ca 100644
--- a/chain/src/tests/find_fork.rs
+++ b/chain/src/tests/find_fork.rs
@@ -9,7 +9,9 @@ use ckb_systemtime::unix_time_as_millis;
 use ckb_test_chain_utils::{MockChain, MockStore};
 use ckb_types::{
     core::{BlockBuilder, BlockExt, BlockView},
-    packed, U256,
+    packed,
+    prelude::Pack,
+    U256,
 };
 use ckb_verification_traits::Switch;
 use dashmap::DashSet;
@@ -429,10 +431,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block1 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .compact_target(parent.compact_target())
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .nonce(1u128)
+        .number((parent.number() + 1).pack())
+        .compact_target(parent.compact_target().pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .nonce(1u128.pack())
         .uncle(uncle)
         .build();
     chain_controller
@@ -448,10 +450,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block2 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .compact_target(parent.compact_target())
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .nonce(2u128)
+        .number((parent.number() + 1).pack())
+        .compact_target(parent.compact_target().pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .nonce(2u128.pack())
         .build();
     parent = new_block2.clone();
     chain_controller
@@ -464,10 +466,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block3 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .compact_target(parent.compact_target())
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .nonce(2u128)
+        .number((parent.number() + 1).pack())
+        .compact_target(parent.compact_target().pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .nonce(2u128.pack())
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block3), Switch::DISABLE_ALL)
@@ -482,10 +484,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block4 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .compact_target(parent.compact_target())
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .nonce(1u128)
+        .number((parent.number() + 1).pack())
+        .compact_target(parent.compact_target().pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .nonce(1u128.pack())
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block4.clone()), Switch::DISABLE_ALL)
@@ -499,10 +501,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block5 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .compact_target(parent.compact_target())
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .nonce(1u128)
+        .number((parent.number() + 1).pack())
+        .compact_target(parent.compact_target().pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .nonce(1u128.pack())
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block5), Switch::DISABLE_ALL)
diff --git a/chain/src/tests/load_code_with_snapshot.rs b/chain/src/tests/load_code_with_snapshot.rs
index 108b89f829..9a51e6e82b 100644
--- a/chain/src/tests/load_code_with_snapshot.rs
+++ b/chain/src/tests/load_code_with_snapshot.rs
@@ -27,9 +27,9 @@ pub(crate) fn create_load_is_even_script_tx() -> TransactionView {
         .witness(load_is_even_script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
         .output(load_is_even_cell.clone())
-        .output_data(load_is_even_data)
+        .output_data(load_is_even_data.pack())
         .output(is_even_lib_cell.clone())
-        .output_data(is_even_lib_data)
+        .output_data(is_even_lib_data.pack())
         .build()
 }
 
@@ -41,15 +41,15 @@ pub(crate) fn create_call_load_is_even_tx(parent: &TransactionView, index: u32)
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .into();
+        .unpack();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
         .cell_dep(CellDep::new_builder().out_point(is_even_lib).build())
         .cell_dep(CellDep::new_builder().out_point(load_is_even).build())
@@ -69,11 +69,11 @@ fn test_load_code() {
         let mut vec = Vec::with_capacity(40);
         vec.extend_from_slice(&number.to_le_bytes());
         vec.extend_from_slice(&data_hash);
-        vec.as_slice().into()
+        vec.pack()
     };
 
     let lock_script = Script::new_builder()
-        .hash_type(ScriptHashType::Data)
+        .hash_type(ScriptHashType::Data.into())
         .code_hash(load_is_even_script.code_hash())
         .args(args)
         .build();
@@ -82,11 +82,11 @@ fn test_load_code() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&load_is_even_script_tx, &issue_tx]).unwrap();
@@ -94,7 +94,7 @@ fn test_load_code() {
     let genesis_block = BlockBuilder::default()
         .transaction(load_is_even_script_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
@@ -130,11 +130,11 @@ fn test_load_code_with_snapshot() {
         let mut vec = Vec::with_capacity(40);
         vec.extend_from_slice(&number.to_le_bytes());
         vec.extend_from_slice(&data_hash);
-        vec.as_slice().into()
+        vec.pack()
     };
 
     let lock_script = Script::new_builder()
-        .hash_type(ScriptHashType::Data)
+        .hash_type(ScriptHashType::Data.into())
         .code_hash(load_is_even_script.code_hash())
         .args(args)
         .build();
@@ -143,11 +143,11 @@ fn test_load_code_with_snapshot() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&load_is_even_script_tx, &issue_tx]).unwrap();
@@ -155,7 +155,7 @@ fn test_load_code_with_snapshot() {
     let genesis_block = BlockBuilder::default()
         .transaction(load_is_even_script_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
@@ -209,11 +209,11 @@ fn _test_load_code_with_snapshot_after_hardfork(script_type: ScriptHashType) {
         let mut vec = Vec::with_capacity(40);
         vec.extend_from_slice(&number.to_le_bytes());
         vec.extend_from_slice(&data_hash);
-        vec.as_slice().into()
+        vec.pack()
     };
 
     let lock_script = Script::new_builder()
-        .hash_type(script_type)
+        .hash_type(script_type.into())
         .code_hash(load_is_even_script.code_hash())
         .args(args)
         .build();
@@ -222,11 +222,11 @@ fn _test_load_code_with_snapshot_after_hardfork(script_type: ScriptHashType) {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&load_is_even_script_tx, &issue_tx]).unwrap();
@@ -234,7 +234,7 @@ fn _test_load_code_with_snapshot_after_hardfork(script_type: ScriptHashType) {
     let genesis_block = BlockBuilder::default()
         .transaction(load_is_even_script_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/load_input_cell_data.rs b/chain/src/tests/load_input_cell_data.rs
index 8e711fb25c..236a952325 100644
--- a/chain/src/tests/load_input_cell_data.rs
+++ b/chain/src/tests/load_input_cell_data.rs
@@ -30,16 +30,16 @@ pub(crate) fn create_load_input_one_byte_transaction(
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .into();
+        .unpack();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
                 .lock(load_input_one_byte_script.clone())
                 .build(),
         )
-        .output_data(Bytes::from(b"1".to_vec()))
+        .output_data(Bytes::from(b"1".to_vec()).pack())
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
         .cell_dep(
             CellDep::new_builder()
@@ -59,11 +59,11 @@ fn test_load_input_one_byte_cell() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(load_input_one_byte_script.clone())
                 .build(),
         )
-        .output_data(Bytes::from(b"1".to_vec()))
+        .output_data(Bytes::from(b"1".to_vec()).pack())
         .build();
 
     let dao = genesis_dao_data(vec![&load_input_one_byte_cell_tx, &issue_tx]).unwrap();
@@ -71,7 +71,7 @@ fn test_load_input_one_byte_cell() {
     let genesis_block = BlockBuilder::default()
         .transaction(load_input_one_byte_cell_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/load_input_data_hash_cell.rs b/chain/src/tests/load_input_data_hash_cell.rs
index ac0502c7e8..b753c1d91f 100644
--- a/chain/src/tests/load_input_data_hash_cell.rs
+++ b/chain/src/tests/load_input_data_hash_cell.rs
@@ -30,16 +30,16 @@ pub(crate) fn create_load_input_data_hash_transaction(
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .into();
+        .unpack();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
                 .lock(load_input_data_hash_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
         .cell_dep(
             CellDep::new_builder()
@@ -59,11 +59,11 @@ fn test_load_input_data_hash_cell() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(load_input_data_hash_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&load_input_data_hash_cell_tx, &issue_tx]).unwrap();
@@ -71,7 +71,7 @@ fn test_load_input_data_hash_cell() {
     let genesis_block = BlockBuilder::default()
         .transaction(load_input_data_hash_cell_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/non_contextual_block_txs_verify.rs b/chain/src/tests/non_contextual_block_txs_verify.rs
index 03cbbb5171..68178658d8 100644
--- a/chain/src/tests/non_contextual_block_txs_verify.rs
+++ b/chain/src/tests/non_contextual_block_txs_verify.rs
@@ -42,11 +42,11 @@ pub(crate) fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity)
+                    .capacity(capacity.pack())
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -72,10 +72,10 @@ pub(crate) fn gen_block(
 
     let block = BlockBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(parent_header.timestamp() + 20_000)
-        .number(number)
-        .compact_target(epoch.compact_target())
-        .epoch(epoch.number_with_fraction(number))
+        .timestamp((parent_header.timestamp() + 20_000).pack())
+        .number(number.pack())
+        .compact_target(epoch.compact_target().pack())
+        .epoch(epoch.number_with_fraction(number).pack())
         .transactions(txs)
         .build();
 
@@ -96,12 +96,12 @@ pub(crate) fn create_transaction(
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .into();
+        .unpack();
 
     let mut builder = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
@@ -113,7 +113,7 @@ pub(crate) fn create_transaction(
         );
 
     if !missing_output_data {
-        builder = builder.output_data(Bytes::new())
+        builder = builder.output_data(Bytes::new().pack())
     }
     builder.build()
 }
@@ -127,11 +127,11 @@ fn non_contextual_block_txs_verify() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -139,7 +139,7 @@ fn non_contextual_block_txs_verify() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/orphan_block_pool.rs b/chain/src/tests/orphan_block_pool.rs
index 5e6aa45775..bc0ba1ceb9 100644
--- a/chain/src/tests/orphan_block_pool.rs
+++ b/chain/src/tests/orphan_block_pool.rs
@@ -5,6 +5,7 @@ use ckb_chain_spec::consensus::ConsensusBuilder;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_types::core::{BlockBuilder, EpochNumberWithFraction, HeaderView};
 use ckb_types::packed::Byte32;
+use ckb_types::prelude::*;
 use std::collections::HashSet;
 use std::sync::Arc;
 use std::thread;
@@ -15,14 +16,10 @@ fn gen_lonely_block(parent_header: &HeaderView) -> LonelyBlock {
     let number = parent_header.number() + 1;
     let block = BlockBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(unix_time_as_millis())
-        .number(number)
-        .epoch(EpochNumberWithFraction::new(
-            number / 1000,
-            number % 1000,
-            1000,
-        ))
-        .nonce(parent_header.nonce() + 1)
+        .timestamp(unix_time_as_millis().pack())
+        .number(number.pack())
+        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
+        .nonce((parent_header.nonce() + 1).pack())
         .build();
     LonelyBlock {
         block: Arc::new(block),
@@ -241,10 +238,10 @@ fn test_remove_expired_blocks() {
     for _ in 1..block_number {
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .timestamp(unix_time_as_millis())
-            .number(parent.number() + 1)
-            .epoch(deprecated)
-            .nonce(parent.nonce() + 1)
+            .timestamp(unix_time_as_millis().pack())
+            .number((parent.number() + 1).pack())
+            .epoch(deprecated.clone().pack())
+            .nonce((parent.nonce() + 1).pack())
             .build();
 
         parent = new_block.header();
diff --git a/chain/src/tests/reward.rs b/chain/src/tests/reward.rs
index f11c7d1792..876a1495bf 100644
--- a/chain/src/tests/reward.rs
+++ b/chain/src/tests/reward.rs
@@ -47,11 +47,11 @@ pub(crate) fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(reward.unwrap_or(capacity))
+                    .capacity(reward.unwrap_or(capacity).pack())
                     .lock(reward_lock)
                     .build(),
             )
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -91,10 +91,10 @@ pub(crate) fn gen_block(
 
     let block = BlockBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(parent_header.timestamp() + 20_000)
-        .number(number)
-        .compact_target(epoch.compact_target())
-        .epoch(epoch.number_with_fraction(number))
+        .timestamp((parent_header.timestamp() + 20_000).pack())
+        .number(number.pack())
+        .compact_target(epoch.compact_target().pack())
+        .epoch(epoch.number_with_fraction(number).pack())
         .dao(dao)
         .transactions(txs)
         .uncles(uncles)
@@ -115,16 +115,16 @@ pub(crate) fn create_transaction(parent: &TransactionView, index: u32) -> Transa
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .into();
+        .unpack();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
         .cell_dep(
             CellDep::new_builder()
@@ -142,11 +142,11 @@ fn finalize_reward() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000))
+                .capacity(capacity_bytes!(5_000).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &tx]).unwrap();
@@ -154,7 +154,7 @@ fn finalize_reward() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(tx.clone())
-        .compact_target(DIFF_TWO)
+        .compact_target(DIFF_TWO.pack())
         .dao(dao)
         .build();
 
@@ -176,19 +176,19 @@ fn finalize_reward() {
 
     let ids: Vec<_> = txs.iter().map(TransactionView::proposal_short_id).collect();
     let mut blocks = Vec::with_capacity(24);
-    let bob_args: packed::Bytes = Bytes::from(b"b0b".to_vec()).into();
+    let bob_args: packed::Bytes = Bytes::from(b"b0b".to_vec()).pack();
 
     let bob = ScriptBuilder::default()
         .args(bob_args)
         .code_hash(always_success_script.code_hash())
-        .hash_type(ScriptHashType::Data)
+        .hash_type(ScriptHashType::Data.into())
         .build();
 
-    let alice_args: packed::Bytes = Bytes::from(b"a11ce".to_vec()).into();
+    let alice_args: packed::Bytes = Bytes::from(b"a11ce".to_vec()).pack();
     let alice = ScriptBuilder::default()
         .args(alice_args)
         .code_hash(always_success_script.code_hash())
-        .hash_type(ScriptHashType::Data)
+        .hash_type(ScriptHashType::Data.into())
         .build();
 
     for i in 1..23 {
diff --git a/chain/src/tests/util.rs b/chain/src/tests/util.rs
index dcfc8df14d..f29cd97ad7 100644
--- a/chain/src/tests/util.rs
+++ b/chain/src/tests/util.rs
@@ -42,18 +42,18 @@ pub(crate) fn start_chain_with_tx_pool_config(
                     .input(CellInput::new(OutPoint::null(), 0))
                     .output(
                         CellOutput::new_builder()
-                            .capacity(capacity_bytes!(50_000))
+                            .capacity(capacity_bytes!(50_000).pack())
                             .lock(always_success_script.clone())
                             .build(),
                     )
-                    .output_data(data)
+                    .output_data(data.pack())
                     .build()
             })
             .collect();
 
         let genesis_block = BlockBuilder::default()
             .dao(dao)
-            .compact_target(DIFF_TWO)
+            .compact_target(DIFF_TWO.pack())
             .transaction(tx)
             .transactions(transactions)
             .build();
diff --git a/chain/src/verify.rs b/chain/src/verify.rs
index 3b6fb4eea9..1b2a007aa1 100644
--- a/chain/src/verify.rs
+++ b/chain/src/verify.rs
@@ -203,7 +203,9 @@ impl ConsumeUnverifiedBlockProcessor {
             match *assume_valid_target {
                 Some(ref target) => {
                     // if the target has been reached, delete it
-                    if target == &Into::<H256>::into(&BlockView::hash(block)) {
+                    if target
+                        == &ckb_types::prelude::Unpack::<H256>::unpack(&BlockView::hash(block))
+                    {
                         assume_valid_target.take();
                         Switch::NONE
                     } else {
diff --git a/ckb-bin/src/subcommand/init.rs b/ckb-bin/src/subcommand/init.rs
index 063defdc3f..b8a72905f8 100644
--- a/ckb-bin/src/subcommand/init.rs
+++ b/ckb-bin/src/subcommand/init.rs
@@ -10,7 +10,7 @@ use ckb_resource::{
     Resource, TemplateContext, AVAILABLE_SPECS, CKB_CONFIG_FILE_NAME, DB_OPTIONS_FILE_NAME,
     MINER_CONFIG_FILE_NAME, SPEC_DEV_FILE_NAME,
 };
-use ckb_types::H256;
+use ckb_types::{prelude::*, H256};
 
 use crate::cli;
 
@@ -81,7 +81,7 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
                     .build_consensus()
                     .expect("Build consensus failed")
                     .get_secp_type_script_hash()
-                    .into();
+                    .unpack();
                 format!("{hash:#x}")
             });
 
diff --git a/ckb-bin/src/subcommand/list_hashes.rs b/ckb-bin/src/subcommand/list_hashes.rs
index 93288d3b0f..b241d92eef 100644
--- a/ckb-bin/src/subcommand/list_hashes.rs
+++ b/ckb-bin/src/subcommand/list_hashes.rs
@@ -1,7 +1,7 @@
 use ckb_app_config::{CKBAppConfig, ExitCode};
 use ckb_chain_spec::ChainSpec;
 use ckb_resource::{Resource, AVAILABLE_SPECS};
-use ckb_types::{packed::CellOutput, H256};
+use ckb_types::{packed::CellOutput, prelude::*, H256};
 use ckb_util::LinkedHashMap;
 use clap::ArgMatches;
 use serde::{Deserialize, Serialize};
@@ -41,7 +41,7 @@ impl TryFrom<ChainSpec> for SpecHashes {
         let hash_option = spec.genesis.hash.take();
         let consensus = spec.build_consensus().map_err(to_config_error)?;
         if let Some(hash) = hash_option {
-            let genesis_hash: H256 = consensus.genesis_hash().into();
+            let genesis_hash: H256 = consensus.genesis_hash().unpack();
             if hash != genesis_hash {
                 eprintln!(
                     "Genesis hash unmatched in {} chainspec config file:\n\
@@ -71,14 +71,14 @@ impl TryFrom<ChainSpec> for SpecHashes {
             )
             .enumerate()
             .map(|(index_minus_one, (resource, (output, data)))| {
-                let data_hash: H256 = CellOutput::calc_data_hash(&data.raw_data()).into();
+                let data_hash: H256 = CellOutput::calc_data_hash(&data.raw_data()).unpack();
                 let type_hash: Option<H256> = output
                     .type_()
                     .to_opt()
-                    .map(|script| script.calc_script_hash().into());
+                    .map(|script| script.calc_script_hash().unpack());
                 SystemCell {
                     path: resource.to_string(),
-                    tx_hash: cellbase.hash().into(),
+                    tx_hash: cellbase.hash().unpack(),
                     index: index_minus_one + 1,
                     data_hash,
                     type_hash,
@@ -97,15 +97,15 @@ impl TryFrom<ChainSpec> for SpecHashes {
                     .iter()
                     .map(|res| res.to_string())
                     .collect::<Vec<_>>(),
-                tx_hash: dep_group_tx.hash().into(),
+                tx_hash: dep_group_tx.hash().unpack(),
                 index,
             })
             .collect::<Vec<_>>();
 
         Ok(SpecHashes {
-            spec_hash: spec.hash.into(),
-            genesis: consensus.genesis_hash().into(),
-            cellbase: cellbase.hash().into(),
+            spec_hash: spec.hash.unpack(),
+            genesis: consensus.genesis_hash().unpack(),
+            cellbase: cellbase.hash().unpack(),
             system_cells: cells_hashes,
             dep_groups,
         })
diff --git a/devtools/ci/ci_main.sh b/devtools/ci/ci_main.sh
index cd9c18edb4..33242b3035 100755
--- a/devtools/ci/ci_main.sh
+++ b/devtools/ci/ci_main.sh
@@ -67,7 +67,7 @@ case $GITHUB_WORKFLOW in
     sudo apt-get install -y gcc-multilib
     sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu clang
     rustup target add aarch64-unknown-linux-gnu
-    curl -LO https://openssl.org/source/old/3.1/openssl-3.1.3.tar.gz
+    curl -LO https://www.openssl.org/source/openssl-3.1.3.tar.gz
     tar -xvzf openssl-3.1.3.tar.gz
     cd openssl-3.1.3
     CC=aarch64-linux-gnu-gcc ./Configure linux-aarch64 shared
diff --git a/miner/src/miner.rs b/miner/src/miner.rs
index 55034f841f..436ea53ca4 100644
--- a/miner/src/miner.rs
+++ b/miner/src/miner.rs
@@ -116,7 +116,8 @@ impl Miner {
         let parent_hash = work.block.header().into_view().parent_hash();
         if !self.legacy_work.contains(&parent_hash) {
             let pow_hash = work.block.header().calc_pow_hash();
-            let (target, _) = compact_to_target(work.block.header().raw().compact_target().into());
+            let (target, _) =
+                compact_to_target(work.block.header().raw().compact_target().unpack());
             self.notify_workers(WorkerMessage::NewWork {
                 pow_hash,
                 work,
@@ -128,7 +129,10 @@ impl Miner {
     fn submit_nonce(&mut self, pow_hash: Byte32, work: Work, nonce: u128) {
         self.notify_workers(WorkerMessage::Stop);
         let raw_header = work.block.header().raw();
-        let header = Header::new_builder().raw(raw_header).nonce(nonce).build();
+        let header = Header::new_builder()
+            .raw(raw_header)
+            .nonce(nonce.pack())
+            .build();
         let block = work
             .block
             .as_advanced_builder()
diff --git a/network/src/protocols/discovery/protocol.rs b/network/src/protocols/discovery/protocol.rs
index 85d23c4287..0950e48784 100644
--- a/network/src/protocols/discovery/protocol.rs
+++ b/network/src/protocols/discovery/protocol.rs
@@ -32,16 +32,18 @@ impl DiscoveryMessage {
                 listen_port,
                 required_flags,
             } => {
+                let version = version.pack();
+                let count = count.pack();
                 let listen_port = packed::PortOpt::new_builder()
                     .set(listen_port.map(|port| {
                         let port_le = port.to_le_bytes();
                         packed::Uint16::new_builder()
-                            .nth0(port_le[0])
-                            .nth1(port_le[1])
+                            .nth0(port_le[0].into())
+                            .nth1(port_le[1].into())
                             .build()
                     }))
                     .build();
-                let required_flags = required_flags.bits();
+                let required_flags = required_flags.bits().pack();
                 let get_node = packed::GetNodes2::new_builder()
                     .listen_port(listen_port)
                     .count(count)
@@ -68,7 +70,7 @@ impl DiscoveryMessage {
                         )
                     }
                     let bytes_vec = packed::BytesVec::new_builder().set(vec_addrs).build();
-                    let flags = item.flags.bits();
+                    let flags = item.flags.bits().pack();
                     let node = packed::Node2::new_builder()
                         .addresses(bytes_vec)
                         .flags(flags)
@@ -116,7 +118,7 @@ impl DiscoveryMessage {
                     let get_nodes2 =
                         packed::GetNodes2::from_compatible_slice(reader.as_slice()).ok()?;
                     let reader = get_nodes2.as_reader();
-                    Flags::from_bits_truncate(reader.required_flags().into())
+                    Flags::from_bits_truncate(reader.required_flags().unpack())
                 } else {
                     Flags::COMPATIBILITY
                 };
@@ -144,7 +146,7 @@ impl DiscoveryMessage {
                         let node2 =
                             packed::Node2::from_compatible_slice(node_reader.as_slice()).ok()?;
                         let reader = node2.as_reader();
-                        Flags::from_bits_truncate(reader.flags().into())
+                        Flags::from_bits_truncate(reader.flags().unpack())
                     } else {
                         Flags::COMPATIBILITY
                     };
diff --git a/network/src/protocols/identify/mod.rs b/network/src/protocols/identify/mod.rs
index 074768ec08..8f2448050d 100644
--- a/network/src/protocols/identify/mod.rs
+++ b/network/src/protocols/identify/mod.rs
@@ -588,9 +588,9 @@ impl Identify {
     fn new(name: String, flags: Flags, client_version: String) -> Self {
         Identify {
             encode_data: packed::Identify::new_builder()
-                .name(name.as_str())
-                .flag(flags.bits())
-                .client_version(client_version.as_str())
+                .name(name.as_str().pack())
+                .flag(flags.bits().pack())
+                .client_version(client_version.as_str().pack())
                 .build()
                 .as_bytes(),
             name,
@@ -613,7 +613,7 @@ impl Identify {
             return None;
         }
 
-        let flag: u64 = reader.flag().into();
+        let flag: u64 = reader.flag().unpack();
         if flag == 0 {
             return None;
         }
diff --git a/network/src/protocols/ping.rs b/network/src/protocols/ping.rs
index e62dfb7cba..984dbf2a15 100644
--- a/network/src/protocols/ping.rs
+++ b/network/src/protocols/ping.rs
@@ -291,10 +291,10 @@ impl PingMessage {
     fn build_ping(nonce: u32) -> Bytes {
         let nonce_le = nonce.to_le_bytes();
         let nonce = packed::Uint32::new_builder()
-            .nth0(nonce_le[0])
-            .nth1(nonce_le[1])
-            .nth2(nonce_le[2])
-            .nth3(nonce_le[3])
+            .nth0(nonce_le[0].into())
+            .nth1(nonce_le[1].into())
+            .nth2(nonce_le[2].into())
+            .nth3(nonce_le[3].into())
             .build();
         let ping = packed::Ping::new_builder().nonce(nonce).build();
         let payload = packed::PingPayload::new_builder().set(ping).build();
@@ -307,10 +307,10 @@ impl PingMessage {
     fn build_pong(nonce: u32) -> Bytes {
         let nonce_le = nonce.to_le_bytes();
         let nonce = packed::Uint32::new_builder()
-            .nth0(nonce_le[0])
-            .nth1(nonce_le[1])
-            .nth2(nonce_le[2])
-            .nth3(nonce_le[3])
+            .nth0(nonce_le[0].into())
+            .nth1(nonce_le[1].into())
+            .nth2(nonce_le[2].into())
+            .nth3(nonce_le[3].into())
             .build();
         let pong = packed::Pong::new_builder().nonce(nonce).build();
         let payload = packed::PingPayload::new_builder().set(pong).build();
diff --git a/pow/src/eaglesong.rs b/pow/src/eaglesong.rs
index 456f131945..f7bb88be27 100644
--- a/pow/src/eaglesong.rs
+++ b/pow/src/eaglesong.rs
@@ -9,11 +9,12 @@ pub struct EaglesongPowEngine;
 
 impl PowEngine for EaglesongPowEngine {
     fn verify(&self, header: &Header) -> bool {
-        let input = crate::pow_message(&header.as_reader().calc_pow_hash(), header.nonce().into());
+        let input =
+            crate::pow_message(&header.as_reader().calc_pow_hash(), header.nonce().unpack());
         let mut output = [0u8; 32];
         eaglesong(&input, &mut output);
 
-        let (block_target, overflow) = compact_to_target(header.raw().compact_target().into());
+        let (block_target, overflow) = compact_to_target(header.raw().compact_target().unpack());
 
         if block_target.is_zero() || overflow {
             debug!(
@@ -42,7 +43,7 @@ impl PowEngine for EaglesongPowEngine {
                 );
                 debug!(
                     "PowEngine::verify error: nonce {:#x}",
-                    Into::<u128>::into(header.nonce())
+                    header.nonce().unpack()
                 );
                 debug!(
                     "PowEngine::verify error: pow input: 0x{:x}",
diff --git a/pow/src/eaglesong_blake2b.rs b/pow/src/eaglesong_blake2b.rs
index fbfbbd6df5..0b87aed9ad 100644
--- a/pow/src/eaglesong_blake2b.rs
+++ b/pow/src/eaglesong_blake2b.rs
@@ -10,14 +10,15 @@ pub struct EaglesongBlake2bPowEngine;
 
 impl PowEngine for EaglesongBlake2bPowEngine {
     fn verify(&self, header: &Header) -> bool {
-        let input = crate::pow_message(&header.as_reader().calc_pow_hash(), header.nonce().into());
+        let input =
+            crate::pow_message(&header.as_reader().calc_pow_hash(), header.nonce().unpack());
         let output = {
             let mut output_tmp = [0u8; 32];
             eaglesong(&input, &mut output_tmp);
             blake2b_256(output_tmp)
         };
 
-        let (block_target, overflow) = compact_to_target(header.raw().compact_target().into());
+        let (block_target, overflow) = compact_to_target(header.raw().compact_target().unpack());
 
         if block_target.is_zero() || overflow {
             debug!(
@@ -50,7 +51,7 @@ impl PowEngine for EaglesongBlake2bPowEngine {
                 );
                 debug!(
                     "PowEngine::verify error: nonce {:#x}",
-                    Into::<u128>::into(header.nonce())
+                    header.nonce().unpack()
                 );
                 debug!(
                     "PowEngine::verify error: pow input: 0x{:x}",
diff --git a/pow/src/tests.rs b/pow/src/tests.rs
index fafeabd3dd..ad4f27ca26 100644
--- a/pow/src/tests.rs
+++ b/pow/src/tests.rs
@@ -1,9 +1,10 @@
 use crate::pow_message;
 use ckb_hash::blake2b_256;
+use ckb_types::prelude::*;
 
 #[test]
 fn test_pow_message() {
-    let zero_hash = blake2b_256([]).into();
+    let zero_hash = blake2b_256([]).pack();
     let nonce = u128::max_value();
     let message = pow_message(&zero_hash, nonce);
     assert_eq!(
diff --git a/rpc/src/module/alert.rs b/rpc/src/module/alert.rs
index fe6a243a03..959ea2e3ee 100644
--- a/rpc/src/module/alert.rs
+++ b/rpc/src/module/alert.rs
@@ -99,7 +99,7 @@ impl AlertRpc for AlertRpcImpl {
     fn send_alert(&self, alert: Alert) -> Result<()> {
         let alert: packed::Alert = alert.into();
         let now_ms = ckb_systemtime::unix_time_as_millis();
-        let notice_until: u64 = alert.raw().notice_until().into();
+        let notice_until: u64 = alert.raw().notice_until().unpack();
         if notice_until < now_ms {
             return Err(RPCError::invalid_params(format!(
                 "Expected `params[0].notice_until` in the future (> {now_ms}), got {notice_until}",
diff --git a/rpc/src/module/chain.rs b/rpc/src/module/chain.rs
index d6288a3876..a82aabb77b 100644
--- a/rpc/src/module/chain.rs
+++ b/rpc/src/module/chain.rs
@@ -1636,7 +1636,7 @@ impl ChainRpc for ChainRpcImpl {
         with_cycles: Option<bool>,
     ) -> Result<Option<BlockResponse>> {
         let snapshot = self.shared.snapshot();
-        let block_hash = block_hash.into();
+        let block_hash = block_hash.pack();
 
         self.get_block_by_hash(&snapshot, &block_hash, verbosity, with_cycles)
     }
@@ -1673,7 +1673,7 @@ impl ChainRpc for ChainRpcImpl {
         verbosity: Option<Uint32>,
     ) -> Result<Option<ResponseFormat<HeaderView>>> {
         let snapshot = self.shared.snapshot();
-        let block_hash = block_hash.into();
+        let block_hash = block_hash.pack();
         if !snapshot.is_main_chain(&block_hash) {
             return Ok(None);
         }
@@ -1731,7 +1731,7 @@ impl ChainRpc for ChainRpcImpl {
 
     fn get_block_filter(&self, block_hash: H256) -> Result<Option<BlockFilter>> {
         let store = self.shared.store();
-        let block_hash = block_hash.into();
+        let block_hash = block_hash.pack();
         if !store.is_main_chain(&block_hash) {
             return Ok(None);
         }
@@ -1752,7 +1752,7 @@ impl ChainRpc for ChainRpcImpl {
         verbosity: Option<Uint32>,
         only_committed: Option<bool>,
     ) -> Result<TransactionWithStatusResponse> {
-        let tx_hash = tx_hash.into();
+        let tx_hash = tx_hash.pack();
         let verbosity = verbosity
             .map(|v| v.value())
             .unwrap_or(DEFAULT_GET_TRANSACTION_VERBOSITY_LEVEL);
@@ -1784,7 +1784,7 @@ impl ChainRpc for ChainRpcImpl {
             .shared
             .snapshot()
             .get_block_hash(block_number.into())
-            .map(|h| h.into()))
+            .map(|h| h.unpack()))
     }
 
     fn get_tip_header(&self, verbosity: Option<Uint32>) -> Result<ResponseFormat<HeaderView>> {
@@ -1806,7 +1806,7 @@ impl ChainRpc for ChainRpcImpl {
 
     fn get_current_epoch(&self) -> Result<EpochView> {
         Ok(EpochView::from_ext(
-            self.shared.snapshot().epoch_ext().into(),
+            self.shared.snapshot().epoch_ext().pack(),
         ))
     }
 
@@ -1817,7 +1817,7 @@ impl ChainRpc for ChainRpcImpl {
             .and_then(|hash| {
                 snapshot
                     .get_epoch_ext(&hash)
-                    .map(|ext| EpochView::from_ext(ext.into()))
+                    .map(|ext| EpochView::from_ext(ext.pack()))
             }))
     }
 
@@ -1848,12 +1848,12 @@ impl ChainRpc for ChainRpcImpl {
     fn get_block_economic_state(&self, block_hash: H256) -> Result<Option<BlockEconomicState>> {
         let snapshot = self.shared.snapshot();
 
-        let block_number =
-            if let Some(block_number) = snapshot.get_block_number(&(&block_hash).into()) {
-                block_number
-            } else {
-                return Ok(None);
-            };
+        let block_number = if let Some(block_number) = snapshot.get_block_number(&block_hash.pack())
+        {
+            block_number
+        } else {
+            return Ok(None);
+        };
 
         let delay_length = snapshot.consensus().finalization_delay_length();
         let finalized_at_number = block_number + delay_length;
@@ -1861,7 +1861,7 @@ impl ChainRpc for ChainRpcImpl {
             return Ok(None);
         }
 
-        let block_hash = (&block_hash).into();
+        let block_hash = block_hash.pack();
         let finalized_at = if let Some(block_hash) = snapshot.get_block_hash(finalized_at_number) {
             block_hash
         } else {
@@ -1920,8 +1920,8 @@ impl ChainRpc for ChainRpcImpl {
     ) -> Result<TransactionProof> {
         let (block, leaf_indices) = self.get_tx_indices(tx_hashes, block_hash)?;
         Ok(TransactionProof {
-            block_hash: block.hash().into(),
-            witnesses_root: block.calc_witnesses_root().into(),
+            block_hash: block.hash().unpack(),
+            witnesses_root: block.calc_witnesses_root().unpack(),
             proof: CBMT::build_merkle_proof(
                 &block
                     .transactions()
@@ -1939,12 +1939,12 @@ impl ChainRpc for ChainRpcImpl {
         let snapshot = self.shared.snapshot();
 
         snapshot
-            .get_block(&(&tx_proof.block_hash).into())
+            .get_block(&tx_proof.block_hash.pack())
             .ok_or_else(|| {
                 RPCError::invalid_params(format!("Cannot find block {:#x}", tx_proof.block_hash))
             })
             .and_then(|block| {
-                let witnesses_root = tx_proof.witnesses_root.into();
+                let witnesses_root = tx_proof.witnesses_root.pack();
                 let merkle_proof = MerkleProof::new(
                     tx_proof
                         .proof
@@ -1956,7 +1956,7 @@ impl ChainRpc for ChainRpcImpl {
                         .proof
                         .lemmas
                         .into_iter()
-                        .map(|lemma| lemma.into())
+                        .map(|lemma| lemma.pack())
                         .collect(),
                 );
 
@@ -1968,7 +1968,7 @@ impl ChainRpc for ChainRpcImpl {
                                 if block.transactions_root()
                                     == merkle_root(&[raw_transactions_root, witnesses_root])
                                 {
-                                    Some(tx_hashes.iter().map(|hash| hash.into()).collect())
+                                    Some(tx_hashes.iter().map(|hash| hash.unpack()).collect())
                                 } else {
                                     None
                                 }
@@ -1985,7 +1985,7 @@ impl ChainRpc for ChainRpcImpl {
     ) -> Result<TransactionAndWitnessProof> {
         let (block, leaf_indices) = self.get_tx_indices(tx_hashes, block_hash)?;
         Ok(TransactionAndWitnessProof {
-            block_hash: block.hash().into(),
+            block_hash: block.hash().unpack(),
             transactions_proof: CBMT::build_merkle_proof(
                 &block
                     .transactions()
@@ -2008,7 +2008,7 @@ impl ChainRpc for ChainRpcImpl {
     ) -> Result<Vec<H256>> {
         let snapshot = self.shared.snapshot();
         snapshot
-            .get_block(&(&tx_proof.block_hash).into())
+            .get_block(&tx_proof.block_hash.pack())
             .ok_or_else(|| {
                 RPCError::invalid_params(format!("Cannot find block {:#x}", tx_proof.block_hash))
             })
@@ -2024,7 +2024,7 @@ impl ChainRpc for ChainRpcImpl {
                         .transactions_proof
                         .lemmas
                         .into_iter()
-                        .map(|lemma| lemma.into())
+                        .map(|lemma| lemma.pack())
                         .collect(),
                 );
                 let witnesses_merkle_proof = MerkleProof::new(
@@ -2038,7 +2038,7 @@ impl ChainRpc for ChainRpcImpl {
                         .witnesses_proof
                         .lemmas
                         .into_iter()
-                        .map(|lemma| lemma.into())
+                        .map(|lemma| lemma.pack())
                         .collect(),
                 );
 
@@ -2055,7 +2055,12 @@ impl ChainRpc for ChainRpcImpl {
                                                 witnesses_proof_root,
                                             ])
                                         {
-                                            Some(tx_hashes.iter().map(|hash| hash.into()).collect())
+                                            Some(
+                                                tx_hashes
+                                                    .iter()
+                                                    .map(|hash| hash.unpack())
+                                                    .collect(),
+                                            )
                                         } else {
                                             None
                                         }
@@ -2075,7 +2080,7 @@ impl ChainRpc for ChainRpcImpl {
         verbosity: Option<Uint32>,
     ) -> Result<Option<ResponseFormat<BlockView>>> {
         let snapshot = self.shared.snapshot();
-        let block_hash = block_hash.into();
+        let block_hash = block_hash.pack();
         if snapshot.is_main_chain(&block_hash) {
             return Ok(None);
         }
@@ -2103,7 +2108,7 @@ impl ChainRpc for ChainRpcImpl {
     }
 
     fn get_block_median_time(&self, block_hash: H256) -> Result<Option<Timestamp>> {
-        let block_hash = block_hash.into();
+        let block_hash = block_hash.pack();
         let snapshot = self.shared.snapshot();
         if !snapshot.is_main_chain(&block_hash) {
             return Ok(None);
@@ -2155,7 +2160,7 @@ impl ChainRpcImpl {
             return Ok(TransactionWithStatus::with_committed(
                 None,
                 tx_info.block_number,
-                tx_info.block_hash.into(),
+                tx_info.block_hash.unpack(),
                 tx_info.index as u32,
                 cycles,
                 None,
@@ -2204,7 +2209,7 @@ impl ChainRpcImpl {
             return Ok(TransactionWithStatus::with_committed(
                 Some(tx),
                 tx_info.block_number,
-                tx_info.block_hash.into(),
+                tx_info.block_hash.unpack(),
                 tx_info.index as u32,
                 cycles,
                 None,
@@ -2291,7 +2296,7 @@ impl ChainRpcImpl {
         let mut retrieved_block_hash = None;
         let mut tx_indices = HashSet::new();
         for tx_hash in tx_hashes {
-            match snapshot.get_transaction_info(&(&tx_hash).into()) {
+            match snapshot.get_transaction_info(&tx_hash.pack()) {
                 Some(tx_info) => {
                     if retrieved_block_hash.is_none() {
                         retrieved_block_hash = Some(tx_info.block_hash);
@@ -2317,7 +2322,7 @@ impl ChainRpcImpl {
 
         let retrieved_block_hash = retrieved_block_hash.expect("checked len");
         if let Some(specified_block_hash) = block_hash {
-            if !retrieved_block_hash.eq(&specified_block_hash.into()) {
+            if !retrieved_block_hash.eq(&specified_block_hash.pack()) {
                 return Err(RPCError::invalid_params(
                     "Not all transactions found in specified block",
                 ));
diff --git a/rpc/src/module/experiment.rs b/rpc/src/module/experiment.rs
index fe768c3719..90e910dc1a 100644
--- a/rpc/src/module/experiment.rs
+++ b/rpc/src/module/experiment.rs
@@ -7,7 +7,7 @@ use ckb_jsonrpc_types::{
 };
 use ckb_shared::{shared::Shared, Snapshot};
 use ckb_store::ChainStore;
-use ckb_types::{core, packed};
+use ckb_types::{core, packed, prelude::*};
 use jsonrpc_core::Result;
 use jsonrpc_utils::rpc;
 
@@ -193,18 +193,18 @@ impl ExperimentRpc for ExperimentRpcImpl {
                     .ok_or_else(|| RPCError::invalid_params("invalid out_point"))?;
                 let output = tx
                     .outputs()
-                    .get(out_point.index().into())
+                    .get(out_point.index().unpack())
                     .ok_or_else(|| RPCError::invalid_params("invalid out_point"))?;
                 let output_data = tx
                     .outputs_data()
-                    .get(out_point.index().into())
+                    .get(out_point.index().unpack())
                     .ok_or_else(|| RPCError::invalid_params("invalid out_point"))?;
 
                 match calculator.calculate_maximum_withdraw(
                     &output,
                     core::Capacity::bytes(output_data.len()).expect("should not overflow"),
                     &deposit_header_hash,
-                    &withdrawing_header_hash.into(),
+                    &withdrawing_header_hash.pack(),
                 ) {
                     Ok(capacity) => Ok(capacity.into()),
                     Err(err) => Err(RPCError::custom_with_error(RPCError::DaoError, err)),
@@ -222,11 +222,11 @@ impl ExperimentRpc for ExperimentRpcImpl {
 
                 let output = withdrawing_tx
                     .outputs()
-                    .get(withdrawing_out_point.index().into())
+                    .get(withdrawing_out_point.index().unpack())
                     .ok_or_else(|| RPCError::invalid_params("invalid withdrawing_out_point"))?;
                 let output_data = withdrawing_tx
                     .outputs_data()
-                    .get(withdrawing_out_point.index().into())
+                    .get(withdrawing_out_point.index().unpack())
                     .ok_or_else(|| RPCError::invalid_params("invalid withdrawing_out_point"))?;
 
                 match calculator.calculate_maximum_withdraw(
diff --git a/rpc/src/module/miner.rs b/rpc/src/module/miner.rs
index 506ba44665..3338c6d5aa 100644
--- a/rpc/src/module/miner.rs
+++ b/rpc/src/module/miner.rs
@@ -332,7 +332,7 @@ impl MinerRpc for MinerRpcImpl {
                     Ok(root) => root,
                     Err(err) => {
                         error!("Generate last state to light client failed: {:?}", err);
-                        return Ok(header.hash().into());
+                        return Ok(header.hash().unpack());
                     }
                 }
             };
@@ -340,7 +340,7 @@ impl MinerRpc for MinerRpcImpl {
             let tip_header = packed::VerifiableHeader::new_builder()
                 .header(header.data())
                 .uncles_hash(block.calc_uncles_hash())
-                .extension(block.extension())
+                .extension(Pack::pack(&block.extension()))
                 .parent_chain_root(parent_chain_root)
                 .build();
             let light_client_message = {
@@ -367,7 +367,7 @@ impl MinerRpc for MinerRpcImpl {
             }
         }
 
-        Ok(header.hash().into())
+        Ok(header.hash().unpack())
     }
 }
 
diff --git a/rpc/src/module/net.rs b/rpc/src/module/net.rs
index dd1fee9c33..de75699e68 100644
--- a/rpc/src/module/net.rs
+++ b/rpc/src/module/net.rs
@@ -8,7 +8,7 @@ use ckb_jsonrpc_types::{
 use ckb_network::{extract_peer_id, multiaddr::Multiaddr, NetworkController};
 use ckb_sync::SyncShared;
 use ckb_systemtime::unix_time_as_millis;
-use ckb_types::packed;
+use ckb_types::prelude::{Pack, Unpack};
 use jsonrpc_core::Result;
 use jsonrpc_utils::rpc;
 use std::sync::Arc;
@@ -740,14 +740,13 @@ impl NetRpc for NetRpcImpl {
         let sync_state = SyncState {
             ibd: chain.is_initial_block_download(),
             assume_valid_target_reached: shared.assume_valid_target().is_none(),
-            assume_valid_target: Into::<packed::Byte32>::into(
-                shared
-                    .assume_valid_target_specified()
-                    .as_ref()
-                    .clone()
-                    .unwrap_or_default(),
-            )
-            .into(),
+            assume_valid_target: shared
+                .assume_valid_target_specified()
+                .as_ref()
+                .clone()
+                .unwrap_or_default()
+                .pack()
+                .into(),
             min_chain_work: min_chain_work.into(),
             min_chain_work_reached: state.min_chain_work_ready(),
             best_known_block_number: best_known.number().into(),
@@ -756,9 +755,9 @@ impl NetRpc for NetRpcImpl {
             inflight_blocks_count: (state.read_inflight_blocks().total_inflight_count() as u64)
                 .into(),
             unverified_tip_number: unverified_tip.number().into(),
-            unverified_tip_hash: unverified_tip.hash().into(),
+            unverified_tip_hash: unverified_tip.hash().unpack(),
             tip_number: chain.tip_number().into(),
-            tip_hash: chain.tip_hash().into(),
+            tip_hash: chain.tip_hash().unpack(),
             fast_time: fast_time.into(),
             normal_time: normal_time.into(),
             low_time: low_time.into(),
diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
index 21e239ca42..a9e65da1c3 100644
--- a/rpc/src/module/pool.rs
+++ b/rpc/src/module/pool.rs
@@ -627,7 +627,7 @@ impl PoolRpc for PoolRpcImpl {
 
         let tx_hash = tx.hash();
         match submit_tx.unwrap() {
-            Ok(_) => Ok(tx_hash.into()),
+            Ok(_) => Ok(tx_hash.unpack()),
             Err(reject) => Err(RPCError::from_submit_transaction_reject(&reject)),
         }
     }
@@ -660,7 +660,7 @@ impl PoolRpc for PoolRpcImpl {
     fn remove_transaction(&self, tx_hash: H256) -> Result<bool> {
         let tx_pool = self.shared.tx_pool_controller();
 
-        tx_pool.remove_local_tx(tx_hash.into()).map_err(|e| {
+        tx_pool.remove_local_tx(tx_hash.pack()).map_err(|e| {
             error!("Send remove_tx request error {}", e);
             RPCError::ckb_internal_error(e)
         })
@@ -718,7 +718,7 @@ impl PoolRpc for PoolRpcImpl {
     fn get_pool_tx_detail_info(&self, tx_hash: H256) -> Result<PoolTxDetailInfo> {
         let tx_pool = self.shared.tx_pool_controller();
         let tx_detail = tx_pool
-            .get_tx_detail(tx_hash.into())
+            .get_tx_detail(tx_hash.pack())
             .map_err(|err| RPCError::custom(RPCError::CKBInternalError, err.to_string()))?;
         Ok(tx_detail.into())
     }
diff --git a/rpc/src/module/stats.rs b/rpc/src/module/stats.rs
index 8df7056955..0dececa47f 100644
--- a/rpc/src/module/stats.rs
+++ b/rpc/src/module/stats.rs
@@ -3,6 +3,7 @@ use ckb_jsonrpc_types::{AlertMessage, ChainInfo, DeploymentInfo, DeploymentPos,
 use ckb_network_alert::notifier::Notifier as AlertNotifier;
 use ckb_shared::shared::Shared;
 use ckb_traits::HeaderFieldsProvider;
+use ckb_types::prelude::Unpack;
 use ckb_util::Mutex;
 use jsonrpc_core::Result;
 use jsonrpc_utils::rpc;
@@ -178,7 +179,7 @@ impl StatsRpc for StatsRpcImpl {
             .collect();
 
         Ok(DeploymentsInfo {
-            hash: snapshot.tip_hash().into(),
+            hash: snapshot.tip_hash().unpack(),
             epoch: snapshot.tip_header().epoch().number().into(),
             deployments,
         })
diff --git a/rpc/src/module/test.rs b/rpc/src/module/test.rs
index a6acf8f08a..1974b39404 100644
--- a/rpc/src/module/test.rs
+++ b/rpc/src/module/test.rs
@@ -621,7 +621,7 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
             }
         }
         if ret.is_ok() {
-            Ok(Some(block.hash().into()))
+            Ok(Some(block.hash().unpack()))
         } else {
             error!("process_block_without_verify error: {:?}", ret);
             Ok(None)
@@ -632,7 +632,7 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
         let header = {
             let snapshot = self.shared.snapshot();
             let header = snapshot
-                .get_block_header(&target_tip_hash.into())
+                .get_block_header(&target_tip_hash.pack())
                 .ok_or_else(|| {
                     RPCError::custom(RPCError::Invalid, "block not found".to_string())
                 })?;
@@ -706,7 +706,7 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
             error!("Send notify_txs request error {}", e);
             return Err(RPCError::ckb_internal_error(e));
         }
-        Ok(tx_hash.into())
+        Ok(tx_hash.unpack())
     }
 
     fn generate_block_with_template(&self, block_template: BlockTemplate) -> Result<H256> {
@@ -722,7 +722,7 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
         let snapshot: &Snapshot = &self.shared.snapshot();
         let consensus = snapshot.consensus();
         let parent_header = snapshot
-            .get_block_header(&(&block_template.parent_hash).into())
+            .get_block_header(&block_template.parent_hash.pack())
             .expect("parent header should be stored");
         let mut seen_inputs = HashSet::new();
 
@@ -800,7 +800,7 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
 
         let tx_hash = tx.hash();
         match submit_tx.unwrap() {
-            Ok(_) => Ok(tx_hash.into()),
+            Ok(_) => Ok(tx_hash.unpack()),
             Err(reject) => Err(RPCError::from_submit_transaction_reject(&reject)),
         }
     }
@@ -825,6 +825,6 @@ impl IntegrationTestRpcImpl {
             error!("Broadcast new block failed: {:?}", err);
         }
 
-        Ok(block_view.header().hash().into())
+        Ok(block_view.header().hash().unpack())
     }
 }
diff --git a/rpc/src/tests/examples.rs b/rpc/src/tests/examples.rs
index 0b2fbd69dc..03afbb9d3c 100644
--- a/rpc/src/tests/examples.rs
+++ b/rpc/src/tests/examples.rs
@@ -18,7 +18,7 @@ use std::path::PathBuf;
 use ckb_types::{
     core::{capacity_bytes, Capacity, TransactionBuilder, TransactionView},
     h256,
-    packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint},
+    packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     prelude::*,
     H256,
 };
@@ -102,10 +102,10 @@ fn collect_code_block(
 }
 
 fn construct_example_transaction() -> TransactionView {
-    let previous_output = OutPoint::new(EXAMPLE_TX_PARENT.clone().into(), 0);
+    let previous_output = OutPoint::new(EXAMPLE_TX_PARENT.clone().pack(), 0);
     let input = CellInput::new(previous_output, 0);
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_cell().2.clone())
         .build();
     let cell_dep = CellDep::new_builder()
@@ -114,7 +114,7 @@ fn construct_example_transaction() -> TransactionView {
     TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .cell_dep(cell_dep)
         .header_dep(always_success_consensus().genesis_hash())
         .build()
@@ -278,7 +278,7 @@ impl RpcTestSuite {
         let example_tx = construct_example_transaction();
         assert_eq!(
             EXAMPLE_TX_HASH,
-            example_tx.hash().into(),
+            example_tx.hash().unpack(),
             "Expect the example tx hash match the constant"
         );
         let example_tx: ckb_jsonrpc_types::Transaction = example_tx.data().into();
diff --git a/rpc/src/tests/mod.rs b/rpc/src/tests/mod.rs
index 800066113b..59a2191b1b 100644
--- a/rpc/src/tests/mod.rs
+++ b/rpc/src/tests/mod.rs
@@ -11,6 +11,7 @@ use ckb_types::{
         TransactionView,
     },
     packed::{CellInput, OutPoint},
+    prelude::*,
 };
 use reqwest::blocking::Client;
 use serde::{Deserialize, Serialize};
@@ -198,10 +199,10 @@ fn next_block(shared: &Shared, parent: &HeaderView) -> BlockView {
     BlockBuilder::default()
         .transaction(cellbase)
         .parent_hash(parent.hash())
-        .number(parent.number() + 1)
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .timestamp(parent.timestamp() + 1)
-        .compact_target(epoch.compact_target())
+        .number((parent.number() + 1).pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .timestamp((parent.timestamp() + 1).pack())
+        .compact_target(epoch.compact_target().pack())
         .dao(dao)
         .build()
 }
@@ -215,7 +216,7 @@ fn always_success_transaction() -> TransactionView {
     TransactionBuilder::default()
         .input(CellInput::new(OutPoint::null(), 0))
         .output(always_success_cell.clone())
-        .output_data(always_success_cell_data)
+        .output_data(always_success_cell_data.to_owned().pack())
         .witness(always_success_script.clone().into_witness())
         .build()
 }
diff --git a/rpc/src/tests/module/miner.rs b/rpc/src/tests/module/miner.rs
index 29b0a6d252..42f9bbb325 100644
--- a/rpc/src/tests/module/miner.rs
+++ b/rpc/src/tests/module/miner.rs
@@ -3,7 +3,7 @@ use ckb_store::ChainStore;
 use ckb_test_chain_utils::{always_success_cell, always_success_consensus};
 use ckb_types::{
     core::{capacity_bytes, Capacity, TransactionBuilder},
-    packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint},
+    packed::{CellDep, CellInput, CellOutputBuilder, OutPoint},
     prelude::*,
 };
 use serde_json::json;
@@ -31,7 +31,7 @@ fn test_get_block_template_cache() {
                 parent
                     .header()
                     .as_advanced_builder()
-                    .timestamp(parent.header().timestamp() + 1)
+                    .timestamp((parent.header().timestamp() + 1).pack())
                     .build(),
             )
             .build();
@@ -67,7 +67,7 @@ fn test_get_block_template_cache() {
 
         let input = CellInput::new(previous_output, 0);
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(always_success_cell().2.clone())
             .build();
         let cell_dep = CellDep::new_builder()
@@ -76,7 +76,7 @@ fn test_get_block_template_cache() {
         let tx = TransactionBuilder::default()
             .input(input)
             .output(output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .cell_dep(cell_dep)
             .build();
 
diff --git a/rpc/src/tests/module/pool.rs b/rpc/src/tests/module/pool.rs
index 560d3d6bc0..f96bb1f24b 100644
--- a/rpc/src/tests/module/pool.rs
+++ b/rpc/src/tests/module/pool.rs
@@ -151,7 +151,8 @@ fn test_send_transaction_exceeded_maximum_ancestors_count() {
                 Capacity::bytes(1000)
                     .unwrap()
                     .safe_sub(Capacity::shannons(i * 41 * 1000))
-                    .unwrap(),
+                    .unwrap()
+                    .pack(),
             )
             .lock(always_success_cell().2.clone())
             .build();
@@ -161,7 +162,7 @@ fn test_send_transaction_exceeded_maximum_ancestors_count() {
         let tx = TransactionBuilder::default()
             .input(input)
             .output(output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .cell_dep(cell_dep)
             .build();
         let new_tx: ckb_jsonrpc_types::Transaction = tx.data().into();
@@ -190,8 +191,8 @@ fn build_tx(
 ) -> core::TransactionView {
     let lock = packed::ScriptBuilder::default()
         .code_hash(code_hash.clone())
-        .hash_type(hash_type)
-        .args(args.as_slice())
+        .hash_type(hash_type.into())
+        .args(args.pack())
         .build();
     core::TransactionBuilder::default()
         .output(packed::CellOutput::new_builder().lock(lock).build())
@@ -207,18 +208,18 @@ fn build_tx_with_type(
 ) -> core::TransactionView {
     let lock = packed::ScriptBuilder::default()
         .code_hash(lock_code_hash.clone())
-        .hash_type(lock_hash_type)
-        .args(lock_args)
+        .hash_type(lock_hash_type.into())
+        .args(lock_args.pack())
         .build();
     let type_ = packed::ScriptBuilder::default()
         .code_hash(type_code_hash.clone())
-        .hash_type(type_hash_type)
+        .hash_type(type_hash_type.into())
         .build();
     core::TransactionBuilder::default()
         .output(
             packed::CellOutput::new_builder()
                 .lock(lock)
-                .type_(Some(type_))
+                .type_(Some(type_).pack())
                 .build(),
         )
         .build()
diff --git a/rpc/src/tests/setup.rs b/rpc/src/tests/setup.rs
index 03a1675973..888186fe57 100644
--- a/rpc/src/tests/setup.rs
+++ b/rpc/src/tests/setup.rs
@@ -23,7 +23,7 @@ use std::{thread::sleep, time::Duration};
 use ckb_types::{
     core::{BlockBuilder, Capacity, EpochNumberWithFraction, Ratio},
     h256,
-    packed::{self, AlertBuilder, RawAlertBuilder},
+    packed::{AlertBuilder, RawAlertBuilder},
     prelude::*,
 };
 
@@ -40,9 +40,9 @@ pub(crate) fn always_success_consensus() -> Consensus {
     let always_success_tx = always_success_transaction();
     let dao = genesis_dao_data(vec![&always_success_tx]).unwrap();
     let genesis = BlockBuilder::default()
-        .timestamp(GENESIS_TIMESTAMP)
-        .compact_target(GENESIS_TARGET)
-        .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0))
+        .timestamp(GENESIS_TIMESTAMP.pack())
+        .compact_target(GENESIS_TARGET.pack())
+        .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).pack())
         .dao(dao)
         .transaction(always_success_tx)
         .build();
@@ -78,7 +78,7 @@ pub(crate) fn setup_rpc_test_suite(height: u64, consensus: Option<Consensus>) ->
             code_hash: h256!("0x1892ea40d82b53c678ff88312450bbb17e164d7a3e0a90941aa58839f56f8df2"),
             hash_type: ckb_jsonrpc_types::ScriptHashType::Type,
             args: json_bytes("0xb2e61ff569acf041b3c2c17724e2379c581eeac3"),
-            message: Into::<packed::Bytes>::into("message").into(),
+            message: "message".pack().into(),
             use_binary_version_as_message_prefix: true,
             binary_version: "TEST".to_string(),
             update_interval_millis: 800,
@@ -154,12 +154,12 @@ pub(crate) fn setup_rpc_test_suite(height: u64, consensus: Option<Consensus>) ->
         let alert = AlertBuilder::default()
             .raw(
                 RawAlertBuilder::default()
-                    .id(42u32)
-                    .min_version(Some("0.0.1".to_string()))
-                    .max_version(Some("1.0.0".to_string()))
-                    .priority(1u32)
-                    .notice_until(ALERT_UNTIL_TIMESTAMP * 1000)
-                    .message("An example alert message!")
+                    .id(42u32.pack())
+                    .min_version(Some("0.0.1".to_string()).pack())
+                    .max_version(Some("1.0.0".to_string()).pack())
+                    .priority(1u32.pack())
+                    .notice_until((ALERT_UNTIL_TIMESTAMP * 1000).pack())
+                    .message("An example alert message!".pack())
                     .build(),
             )
             .build();
@@ -258,7 +258,7 @@ pub(crate) fn setup_rpc_test_suite(height: u64, consensus: Option<Consensus>) ->
                 parent
                     .header()
                     .as_advanced_builder()
-                    .timestamp(parent.header().timestamp() + 1)
+                    .timestamp((parent.header().timestamp() + 1).pack())
                     .build(),
             )
             .build();
diff --git a/script/fuzz/fuzz_targets/syscall_exec.rs b/script/fuzz/fuzz_targets/syscall_exec.rs
index 63e6d69ccd..7e03cabcb5 100644
--- a/script/fuzz/fuzz_targets/syscall_exec.rs
+++ b/script/fuzz/fuzz_targets/syscall_exec.rs
@@ -45,16 +45,16 @@ impl ExtensionProvider for MockDataLoader {
 
 fn mock_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64.into())
-        .block_epoch(0u64.into())
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.into())
+                .index(1u32.pack())
                 .build(),
         )
         .build()
-        .into()
+        .unpack()
 }
 
 static CALLER: &[u8] = include_bytes!("../programs/exec_caller");
@@ -103,13 +103,13 @@ fn run(data: FuzzData) {
     };
 
     let exec_caller_cell = CellOutput::new_builder()
-        .capacity(Capacity::bytes(exec_caller_cell_data.len()).unwrap().into())
+        .capacity(Capacity::bytes(exec_caller_cell_data.len()).unwrap().pack())
         .build();
     let exec_callee_cell = CellOutput::new_builder()
-        .capacity(Capacity::bytes(exec_callee_cell_data.len()).unwrap().into())
+        .capacity(Capacity::bytes(exec_callee_cell_data.len()).unwrap().pack())
         .build();
     let exec_caller_data_cell = CellOutput::new_builder()
-        .capacity(Capacity::bytes(exec_caller_data_data.len()).unwrap().into())
+        .capacity(Capacity::bytes(exec_caller_data_data.len()).unwrap().pack())
         .build();
 
     let exec_caller_script = Script::new_builder()
@@ -117,14 +117,14 @@ fn run(data: FuzzData) {
         .code_hash(CellOutput::calc_data_hash(&exec_caller_cell_data))
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
     let transaction = TransactionBuilder::default()
         .input(input)
-        .set_witnesses(vec![exec_callee_cell_data.into()])
+        .set_witnesses(vec![exec_callee_cell_data.pack()])
         .build();
 
     let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
@@ -154,7 +154,7 @@ fn run(data: FuzzData) {
     let provider = MockDataLoader {};
     let consensus = ConsensusBuilder::default().build();
     let tx_verify_env =
-        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.pack()).build());
     let verifier = TransactionScriptsVerifier::new(
         rtx.into(),
         provider,
diff --git a/script/fuzz/fuzz_targets/syscall_spawn.rs b/script/fuzz/fuzz_targets/syscall_spawn.rs
index 7c87e9f879..8782bee23a 100644
--- a/script/fuzz/fuzz_targets/syscall_spawn.rs
+++ b/script/fuzz/fuzz_targets/syscall_spawn.rs
@@ -47,16 +47,16 @@ impl ExtensionProvider for MockDataLoader {
 
 fn mock_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64)
-        .block_epoch(0u64)
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32)
+                .index(1u32.pack())
                 .build(),
         )
         .build()
-        .into()
+        .unpack()
 }
 
 static PROGRAM_DATA: &[u8] = include_bytes!("../../testdata/spawn_fuzzing");
@@ -69,7 +69,7 @@ fn run(data: &[u8]) {
     let split_offset = usize::min(split_offset, data.len() - 1);
     let parent_witness = Bytes::copy_from_slice(&data[0..split_offset]);
     let child_witness = Bytes::copy_from_slice(&data[split_offset..]);
-    let witnesses = vec![parent_witness.into(), child_witness.into()];
+    let witnesses = vec![parent_witness.pack(), child_witness.pack()];
 
     let transaction = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::null(), 0))
@@ -83,17 +83,17 @@ fn run(data: &[u8]) {
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(
         CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0"), 0))
+    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(script)
             .build(),
         Bytes::new(),
@@ -121,7 +121,7 @@ fn run(data: &[u8]) {
         .hardfork_switch(hardfork_switch)
         .build();
     let tx_verify_env =
-        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.pack()).build());
     let verifier = TransactionScriptsVerifier::new(
         rtx.into(),
         provider,
diff --git a/script/fuzz/fuzz_targets/transaction_scripts_verifier_data0.rs b/script/fuzz/fuzz_targets/transaction_scripts_verifier_data0.rs
index 3c2591d51c..ccb922337e 100644
--- a/script/fuzz/fuzz_targets/transaction_scripts_verifier_data0.rs
+++ b/script/fuzz/fuzz_targets/transaction_scripts_verifier_data0.rs
@@ -47,16 +47,16 @@ impl ExtensionProvider for MockDataLoader {
 
 fn mock_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64.into())
-        .block_epoch(0u64.into())
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.into())
+                .index(1u32.pack())
                 .build(),
         )
         .build()
-        .into()
+        .unpack()
 }
 
 fn run(data: &[u8]) {
@@ -71,17 +71,17 @@ fn run(data: &[u8]) {
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(
         CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap().into())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").into(), 0))
+    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100).pack())
             .lock(script)
             .build(),
         Bytes::new(),
@@ -105,7 +105,7 @@ fn run(data: &[u8]) {
         .hardfork_switch(hardfork_switch)
         .build();
     let tx_verify_env =
-        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.pack()).build());
     let verifier = TransactionScriptsVerifier::new(
         rtx.into(),
         provider,
diff --git a/script/fuzz/fuzz_targets/transaction_scripts_verifier_data1.rs b/script/fuzz/fuzz_targets/transaction_scripts_verifier_data1.rs
index b005620b01..f9be40d6be 100644
--- a/script/fuzz/fuzz_targets/transaction_scripts_verifier_data1.rs
+++ b/script/fuzz/fuzz_targets/transaction_scripts_verifier_data1.rs
@@ -47,16 +47,16 @@ impl ExtensionProvider for MockDataLoader {
 
 fn mock_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64.into())
-        .block_epoch(0u64.into())
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.into())
+                .index(1u32.pack())
                 .build(),
         )
         .build()
-        .into()
+        .unpack()
 }
 
 fn run(data: &[u8]) {
@@ -71,17 +71,17 @@ fn run(data: &[u8]) {
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(
         CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap().into())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").into(), 0))
+    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100).pack())
             .lock(script)
             .build(),
         Bytes::new(),
@@ -105,7 +105,7 @@ fn run(data: &[u8]) {
         .hardfork_switch(hardfork_switch)
         .build();
     let tx_verify_env =
-        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.pack()).build());
     let verifier = TransactionScriptsVerifier::new(
         rtx.into(),
         provider,
diff --git a/script/fuzz/fuzz_targets/transaction_scripts_verifier_data2.rs b/script/fuzz/fuzz_targets/transaction_scripts_verifier_data2.rs
index c14fb5d109..8c05a5baab 100644
--- a/script/fuzz/fuzz_targets/transaction_scripts_verifier_data2.rs
+++ b/script/fuzz/fuzz_targets/transaction_scripts_verifier_data2.rs
@@ -47,16 +47,16 @@ impl ExtensionProvider for MockDataLoader {
 
 fn mock_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64.into())
-        .block_epoch(0u64.into())
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.into())
+                .index(1u32.pack())
                 .build(),
         )
         .build()
-        .into()
+        .unpack()
 }
 
 fn run(data: &[u8]) {
@@ -71,17 +71,17 @@ fn run(data: &[u8]) {
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(
         CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap().into())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").into(), 0))
+    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100).pack())
             .lock(script)
             .build(),
         Bytes::new(),
@@ -105,7 +105,7 @@ fn run(data: &[u8]) {
         .hardfork_switch(hardfork_switch)
         .build();
     let tx_verify_env =
-        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.pack()).build());
     let verifier = TransactionScriptsVerifier::new(
         rtx.into(),
         provider,
diff --git a/script/src/syscalls/load_cell.rs b/script/src/syscalls/load_cell.rs
index e7f4253e1e..0dee77937f 100644
--- a/script/src/syscalls/load_cell.rs
+++ b/script/src/syscalls/load_cell.rs
@@ -109,7 +109,7 @@ impl<DL: CellDataProvider> LoadCell<DL> {
 
         let result = match field {
             CellField::Capacity => {
-                let capacity: Capacity = output.capacity().into();
+                let capacity: Capacity = output.capacity().unpack();
                 let mut buffer = vec![];
                 buffer.write_u64::<LittleEndian>(capacity.as_u64())?;
                 (SUCCESS, store_data(machine, &buffer)?)
diff --git a/script/src/syscalls/load_input.rs b/script/src/syscalls/load_input.rs
index 33f427e822..8f19c0d6c9 100644
--- a/script/src/syscalls/load_input.rs
+++ b/script/src/syscalls/load_input.rs
@@ -80,7 +80,7 @@ impl LoadInput {
             }
             InputField::Since => {
                 let mut buffer = vec![];
-                buffer.write_u64::<LittleEndian>(input.since().into())?;
+                buffer.write_u64::<LittleEndian>(input.since().unpack())?;
                 store_data(machine, &buffer)
             }
         }
diff --git a/script/src/syscalls/tests/utils.rs b/script/src/syscalls/tests/utils.rs
index 920f362265..de9ca6f542 100644
--- a/script/src/syscalls/tests/utils.rs
+++ b/script/src/syscalls/tests/utils.rs
@@ -41,7 +41,7 @@ pub(crate) fn new_mock_data_loader() -> MockDataLoader {
 
 pub(crate) fn build_cell_meta(capacity_bytes: usize, data: Bytes) -> CellMeta {
     let capacity = Capacity::bytes(capacity_bytes).expect("capacity bytes overflow");
-    let builder = CellOutput::new_builder().capacity(capacity);
+    let builder = CellOutput::new_builder().capacity(capacity.pack());
     let data_hash = CellOutput::calc_data_hash(&data);
     CellMeta {
         out_point: OutPoint::default(),
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_1.rs b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
index 99bb2ec7b1..761537e2ff 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_1.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
@@ -7,7 +7,7 @@ use ckb_types::{
         Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType, TransactionBuilder,
         TransactionInfo,
     },
-    packed::{self, CellInput, CellOutput, OutPoint, Script, ScriptBuilder},
+    packed::{CellInput, CellOutput, OutPoint, Script, ScriptBuilder},
     prelude::*,
     H256,
 };
@@ -438,7 +438,7 @@ fn _test_load_cell_capacity(capacity: Capacity) -> Result<(), TestCaseError> {
     let input_cell = CellMeta {
         out_point: OutPoint::default(),
         transaction_info: None,
-        cell_output: CellOutput::new_builder().capacity(capacity).build(),
+        cell_output: CellOutput::new_builder().capacity(capacity.pack()).build(),
         data_bytes: 0,
         mem_cell_data: Some(data),
         mem_cell_data_hash: Some(data_hash),
@@ -499,7 +499,7 @@ fn _test_load_cell_occupied_capacity(data: &[u8]) -> Result<(), TestCaseError> {
     let input_cell = CellMeta {
         out_point: OutPoint::default(),
         transaction_info: None,
-        cell_output: CellOutput::new_builder().capacity(100).build(),
+        cell_output: CellOutput::new_builder().capacity(100.pack()).build(),
         data_bytes: 0,
         mem_cell_data: Some(data),
         mem_cell_data_hash: Some(data_hash),
@@ -561,7 +561,7 @@ fn test_load_missing_data_hash() {
     let input_cell = CellMeta {
         out_point: OutPoint::default(),
         transaction_info: None,
-        cell_output: CellOutput::new_builder().capacity(100).build(),
+        cell_output: CellOutput::new_builder().capacity(100.pack()).build(),
         data_bytes: 0,
         mem_cell_data: None,
         mem_cell_data_hash: None,
@@ -655,7 +655,7 @@ fn _test_load_header(
     machine.set_register(A4, source); //source: 4 header
     machine.set_register(A7, LOAD_HEADER_SYSCALL_NUMBER); // syscall number
 
-    let data_hash = blake2b_256(data);
+    let data_hash = blake2b_256(data).pack();
     let header = HeaderBuilder::default()
         .transactions_root(data_hash)
         .build();
@@ -671,7 +671,7 @@ fn _test_load_header(
             block_epoch: header.epoch(),
             index: 1,
         }),
-        cell_output: CellOutput::new_builder().capacity(100).build(),
+        cell_output: CellOutput::new_builder().capacity(100.pack()).build(),
         data_bytes: 0,
         mem_cell_data: None,
         mem_cell_data_hash: None,
@@ -775,9 +775,9 @@ fn _test_load_header_by_field(data: &[u8], field: HeaderField) -> Result<(), Tes
     let data_hash: H256 = blake2b_256(data).into();
     let epoch = EpochNumberWithFraction::new(1, 40, 1000);
     let header = HeaderBuilder::default()
-        .transactions_root(data_hash)
-        .number(2000)
-        .epoch(epoch)
+        .transactions_root(data_hash.pack())
+        .number(2000.pack())
+        .epoch(epoch.pack())
         .build();
 
     let mut correct_data = [0u8; 8];
@@ -847,7 +847,9 @@ fn _test_load_tx_hash(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A2, 0); // offset
     machine.set_register(A7, LOAD_TX_HASH_SYSCALL_NUMBER); // syscall number
 
-    let transaction_view = TransactionBuilder::default().output_data(data).build();
+    let transaction_view = TransactionBuilder::default()
+        .output_data(data.pack())
+        .build();
 
     let hash = transaction_view.hash();
     let hash_len = 32u64;
@@ -896,7 +898,9 @@ fn _test_load_tx(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A2, 0); // offset
     machine.set_register(A7, LOAD_TRANSACTION_SYSCALL_NUMBER); // syscall number
 
-    let transaction_view = TransactionBuilder::default().output_data(data).build();
+    let transaction_view = TransactionBuilder::default()
+        .output_data(data.pack())
+        .build();
 
     let tx = transaction_view.data();
     let tx_len = transaction_view.data().as_slice().len() as u64;
@@ -946,8 +950,8 @@ fn _test_load_current_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_SCRIPT_HASH_SYSCALL_NUMBER); // syscall number
 
     let script = Script::new_builder()
-        .args(Bytes::from(data.to_owned()))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(data.to_owned()).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let hash = script.calc_script_hash();
     let data = hash.raw_data();
@@ -1001,8 +1005,8 @@ fn _test_load_input_lock_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_CELL_BY_FIELD_SYSCALL_NUMBER); // syscall number
 
     let script = Script::new_builder()
-        .args(Bytes::from(data.to_owned()))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(data.to_owned()).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let h = script.calc_script_hash();
     let hash = h.as_bytes();
@@ -1067,8 +1071,8 @@ fn _test_load_input_lock_script(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_CELL_BY_FIELD_SYSCALL_NUMBER); // syscall number
 
     let script = Script::new_builder()
-        .args(Bytes::from(data.to_owned()))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(data.to_owned()).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let lock = script.as_slice();
 
@@ -1135,8 +1139,8 @@ fn _test_load_input_type_script(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_CELL_BY_FIELD_SYSCALL_NUMBER); // syscall number
 
     let script = Script::new_builder()
-        .args(Bytes::from(data.to_owned()))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(data.to_owned()).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let type_ = script.as_slice();
 
@@ -1145,7 +1149,7 @@ fn _test_load_input_type_script(data: &[u8]) -> Result<(), TestCaseError> {
         .cell_output
         .clone()
         .as_builder()
-        .type_(Some(script.to_owned()))
+        .type_(Some(script.to_owned()).pack())
         .build();
     input_cell.cell_output = output_with_type;
 
@@ -1203,8 +1207,8 @@ fn _test_load_input_type_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_CELL_BY_FIELD_SYSCALL_NUMBER); // syscall number
 
     let script = Script::new_builder()
-        .args(Bytes::from(data.to_owned()))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(data.to_owned()).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
 
     let type_h = script.calc_script_hash();
@@ -1215,7 +1219,7 @@ fn _test_load_input_type_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
         .cell_output
         .clone()
         .as_builder()
-        .type_(Some(script))
+        .type_(Some(script).pack())
         .build();
     input_cell.cell_output = output_with_type;
     let outputs = Arc::new(vec![]);
@@ -1270,7 +1274,7 @@ fn _test_load_witness(data: &[u8], source: SourceEntry) -> Result<(), TestCaseEr
     machine.set_register(A4, u64::from(Source::Transaction(source))); //source
     machine.set_register(A7, LOAD_WITNESS_SYSCALL_NUMBER); // syscall number
 
-    let witness: packed::Bytes = Bytes::from(data.to_owned()).into();
+    let witness = Bytes::from(data.to_owned()).pack();
 
     let witness_correct_data = witness.raw_data();
 
@@ -1279,7 +1283,7 @@ fn _test_load_witness(data: &[u8], source: SourceEntry) -> Result<(), TestCaseEr
     let group_outputs = Arc::new(vec![]);
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default()
-            .witnesses(Into::<packed::BytesVec>::into(witnesses))
+            .witnesses(witnesses.pack())
             .build(),
         resolved_cell_deps: vec![],
         resolved_inputs: vec![],
@@ -1334,17 +1338,17 @@ fn _test_load_group_witness(data: &[u8], source: SourceEntry) -> Result<(), Test
     machine.set_register(A4, u64::from(Source::Group(source))); //source
     machine.set_register(A7, LOAD_WITNESS_SYSCALL_NUMBER); // syscall number
 
-    let witness: packed::Bytes = Bytes::from(data.to_owned()).into();
+    let witness = Bytes::from(data.to_owned()).pack();
 
     let witness_correct_data = witness.raw_data();
 
-    let dummy_witness = Bytes::default().into();
+    let dummy_witness = Bytes::default().pack();
     let witnesses = vec![dummy_witness, witness];
     let group_inputs = Arc::new(vec![1]);
     let group_outputs = Arc::new(vec![1]);
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default()
-            .witnesses(Into::<packed::BytesVec>::into(witnesses))
+            .witnesses(witnesses.pack())
             .build(),
         resolved_cell_deps: vec![],
         resolved_inputs: vec![],
@@ -1393,7 +1397,7 @@ fn _test_load_script(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_SCRIPT_SYSCALL_NUMBER); // syscall number
 
     let script = ScriptBuilder::default()
-        .args(Bytes::from(data.to_owned()))
+        .args(Bytes::from(data.to_owned()).pack())
         .build();
     let script_correct_data = script.as_slice();
 
@@ -1454,7 +1458,7 @@ fn _test_load_cell_data_as_code(
     let data_loader = new_mock_data_loader();
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default()
-            .output_data(data.clone())
+            .output_data(data.pack())
             .build(),
         resolved_cell_deps: vec![dep_cell],
         resolved_inputs: vec![input_cell],
@@ -1527,7 +1531,7 @@ fn _test_load_cell_data(
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default()
-            .output_data(data.clone())
+            .output_data(data.pack())
             .build(),
         resolved_cell_deps: vec![dep_cell],
         resolved_inputs: vec![input_cell],
@@ -1958,10 +1962,15 @@ fn _test_load_input(
     prop_assert!(machine.memory_mut().store64(&size_addr, &addr_size).is_ok());
 
     let data = Bytes::from(data.to_owned());
-    let hash = blake2b_256(&data);
+    let hash = blake2b_256(&data).pack();
     let input = CellInput::new_builder()
-        .previous_output(OutPoint::new_builder().tx_hash(hash).index(0u32).build())
-        .since(10u64)
+        .previous_output(
+            OutPoint::new_builder()
+                .tx_hash(hash)
+                .index(0u32.pack())
+                .build(),
+        )
+        .since(10u64.pack())
         .build();
     let previous_output = input.previous_output();
 
@@ -1979,7 +1988,7 @@ fn _test_load_input(
         match field {
             InputField::OutPoint => previous_output.as_slice(),
             InputField::Since => {
-                buffer.write_u64::<LittleEndian>(input.since().into())?;
+                buffer.write_u64::<LittleEndian>(input.since().unpack())?;
                 buffer.as_slice()
             }
         }
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_2.rs b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
index 07d2eb6db2..4cac872f56 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_2.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
@@ -87,14 +87,14 @@ fn _test_load_extension(
             block_epoch: header.epoch(),
             index: 1,
         }),
-        cell_output: CellOutput::new_builder().capacity(100).build(),
+        cell_output: CellOutput::new_builder().capacity(100.pack()).build(),
         data_bytes: 0,
         mem_cell_data: None,
         mem_cell_data_hash: None,
     };
 
     let mut extensions = HashMap::default();
-    extensions.insert(header.hash(), (&data).into());
+    extensions.insert(header.hash(), data.pack());
     let data_loader = MockDataLoader {
         extensions,
         ..Default::default()
diff --git a/script/src/verify.rs b/script/src/verify.rs
index a79e3d8c92..f91328e598 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -407,7 +407,7 @@ where
                 .map(|(index, (cell_output, data))| {
                     let out_point = OutPoint::new_builder()
                         .tx_hash(tx_hash.clone())
-                        .index(index)
+                        .index(index.pack())
                         .build();
                     let data_hash = CellOutput::calc_data_hash(&data);
                     CellMeta {
@@ -962,7 +962,7 @@ where
         group: &ScriptGroup,
         max_cycles: Cycle,
     ) -> Result<Cycle, ScriptError> {
-        if group.script.code_hash() == TYPE_ID_CODE_HASH.into()
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.pack()
             && Into::<u8>::into(group.script.hash_type()) == Into::<u8>::into(ScriptHashType::Type)
         {
             let verifier = TypeIdSystemScript {
@@ -1000,7 +1000,7 @@ where
         max_cycles: Cycle,
         state: &Option<FullSuspendedState>,
     ) -> Result<ChunkState, ScriptError> {
-        if group.script.code_hash() == TYPE_ID_CODE_HASH.into()
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.pack()
             && Into::<u8>::into(group.script.hash_type()) == Into::<u8>::into(ScriptHashType::Type)
         {
             let verifier = TypeIdSystemScript {
@@ -1078,7 +1078,7 @@ where
         max_cycles: Cycle,
         command_rx: &mut Receiver<ChunkCommand>,
     ) -> Result<Cycle, ScriptError> {
-        if group.script.code_hash() == TYPE_ID_CODE_HASH.into()
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.pack()
             && Into::<u8>::into(group.script.hash_type()) == Into::<u8>::into(ScriptHashType::Type)
         {
             let verifier = TypeIdSystemScript {
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2019.rs b/script/src/verify/tests/ckb_latest/features_since_v2019.rs
index 2cfa0ea806..a69c887575 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2019.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2019.rs
@@ -25,7 +25,7 @@ fn check_always_success_hash() {
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_script.clone())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -68,13 +68,13 @@ fn check_signature() {
     args.extend(&to_hex_signature(&signature));
 
     let code_hash = blake2b_256(&buffer);
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap())
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
         .transaction_info(default_transaction_info())
@@ -82,9 +82,9 @@ fn check_signature() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
-        .code_hash(code_hash)
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(args).pack())
+        .code_hash(code_hash.pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -94,7 +94,7 @@ fn check_signature() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -137,19 +137,22 @@ fn check_signature_referenced_via_type_hash() {
     args.extend(&to_hex_pubkey(&pubkey));
     args.extend(&to_hex_signature(&signature));
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap())
-        .type_(Some(
-            Script::new_builder()
-                .code_hash(h256!("0x123456abcd90"))
-                .hash_type(ScriptHashType::Data)
-                .build(),
-        ))
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
+        .type_(
+            Some(
+                Script::new_builder()
+                    .code_hash(h256!("0x123456abcd90").pack())
+                    .hash_type(ScriptHashType::Data.into())
+                    .build(),
+            )
+            .pack(),
+        )
         .build();
     let type_hash = output.type_().to_opt().as_ref().unwrap().calc_script_hash();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
@@ -158,9 +161,9 @@ fn check_signature_referenced_via_type_hash() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
+        .args(Bytes::from(args).pack())
         .code_hash(type_hash)
-        .hash_type(ScriptHashType::Type)
+        .hash_type(ScriptHashType::Type.into())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -170,7 +173,7 @@ fn check_signature_referenced_via_type_hash() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -210,20 +213,20 @@ fn check_invalid_signature() {
     args.extend(&to_hex_signature(&signature));
 
     let code_hash = blake2b_256(&buffer);
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder().out_point(dep_out_point).build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap())
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
         .transaction_info(default_transaction_info())
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
-        .code_hash(code_hash)
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(args).pack())
+        .code_hash(code_hash.pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -233,7 +236,7 @@ fn check_invalid_signature() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -267,14 +270,14 @@ fn check_invalid_dep_reference() {
     args.extend(&to_hex_pubkey(&pubkey));
     args.extend(&to_hex_signature(&signature));
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder().out_point(dep_out_point).build();
 
-    let script_code_hash: Byte32 = blake2b_256(&buffer).into();
+    let script_code_hash = blake2b_256(&buffer).pack();
     let script = Script::new_builder()
-        .args(Bytes::from(args))
+        .args(Bytes::from(args).pack())
         .code_hash(script_code_hash.clone())
-        .hash_type(ScriptHashType::Data)
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -284,7 +287,7 @@ fn check_invalid_dep_reference() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -322,7 +325,7 @@ fn check_output_contract() {
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -334,28 +337,28 @@ fn check_output_contract() {
     .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
-        .code_hash(blake2b_256(&buffer))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(args).pack())
+        .code_hash(blake2b_256(&buffer).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let output_data = Bytes::default();
     let output = CellOutputBuilder::default()
         .lock(
             Script::new_builder()
-                .hash_type(ScriptHashType::Data)
+                .hash_type(ScriptHashType::Data.into())
                 .build(),
         )
-        .type_(Some(script))
+        .type_(Some(script).pack())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let dep_cell = {
         let data = Bytes::from(buffer);
         let output = CellOutputBuilder::default()
-            .capacity(Capacity::bytes(data.len()).unwrap())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build();
         CellMetaBuilder::from_cell_output(output, data)
             .transaction_info(default_transaction_info())
@@ -366,7 +369,7 @@ fn check_output_contract() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(output_data)
+        .output_data(output_data.pack())
         .cell_dep(cell_dep)
         .build();
 
@@ -403,7 +406,7 @@ fn check_invalid_output_contract() {
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -415,20 +418,20 @@ fn check_invalid_output_contract() {
     .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
-        .code_hash(blake2b_256(&buffer))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(args).pack())
+        .code_hash(blake2b_256(&buffer).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let output = CellOutputBuilder::default()
-        .type_(Some(script.clone()))
+        .type_(Some(script.clone()).pack())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder().out_point(dep_out_point).build();
     let dep_cell = {
         let dep_cell_data = Bytes::from(buffer);
         let output = CellOutputBuilder::default()
-            .capacity(Capacity::bytes(dep_cell_data.len()).unwrap())
+            .capacity(Capacity::bytes(dep_cell_data.len()).unwrap().pack())
             .build();
         CellMetaBuilder::from_cell_output(output, dep_cell_data)
             .transaction_info(default_transaction_info())
@@ -438,7 +441,7 @@ fn check_invalid_output_contract() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .cell_dep(cell_dep)
         .build();
 
@@ -474,18 +477,18 @@ fn check_same_lock_and_type_script_are_executed_twice() {
     args.extend(&to_hex_signature(&signature));
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
-        .code_hash(blake2b_256(&buffer))
-        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(args).pack())
+        .code_hash(blake2b_256(&buffer).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap())
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
         .transaction_info(default_transaction_info())
@@ -499,9 +502,9 @@ fn check_same_lock_and_type_script_are_executed_twice() {
 
     // The lock and type scripts here are both executed.
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script.clone())
-        .type_(Some(script))
+        .type_(Some(script).pack())
         .build();
     let dummy_cell = create_dummy_cell(output);
 
@@ -524,25 +527,25 @@ fn check_type_id_one_in_one_out() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()))
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script))
+        .type_(Some(type_id_script).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -589,25 +592,25 @@ fn check_type_id_one_in_one_out_not_enough_cycles() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()))
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script))
+        .type_(Some(type_id_script).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -654,11 +657,11 @@ fn check_type_id_creation() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
         .build();
 
@@ -672,15 +675,15 @@ fn check_type_id_creation() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash)
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(input_hash.pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script))
+        .type_(Some(type_id_script).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -721,23 +724,23 @@ fn check_type_id_termination() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()))
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script))
+        .type_(Some(type_id_script).pack())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
         .build();
 
@@ -779,11 +782,11 @@ fn check_type_id_invalid_creation() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
         .build();
 
@@ -791,7 +794,7 @@ fn check_type_id_invalid_creation() {
         let mut blake2b = new_blake2b();
         blake2b.update(&input.previous_output().tx_hash().as_bytes());
         let mut buf = [0; 4];
-        LittleEndian::write_u32(&mut buf, input.previous_output().index().into());
+        LittleEndian::write_u32(&mut buf, input.previous_output().index().unpack());
         blake2b.update(&buf[..]);
         let mut buf = [0; 8];
         LittleEndian::write_u64(&mut buf, 0);
@@ -803,15 +806,15 @@ fn check_type_id_invalid_creation() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash)
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(input_hash.pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -855,11 +858,11 @@ fn check_type_id_invalid_creation_length() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
         .build();
 
@@ -867,7 +870,7 @@ fn check_type_id_invalid_creation_length() {
         let mut blake2b = new_blake2b();
         blake2b.update(&input.previous_output().tx_hash().as_bytes());
         let mut buf = [0; 4];
-        LittleEndian::write_u32(&mut buf, input.previous_output().index().into());
+        LittleEndian::write_u32(&mut buf, input.previous_output().index().unpack());
         blake2b.update(&buf[..]);
         let mut buf = [0; 8];
         LittleEndian::write_u64(&mut buf, 0);
@@ -882,15 +885,15 @@ fn check_type_id_invalid_creation_length() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash)
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(input_hash.pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -934,30 +937,30 @@ fn check_type_id_one_in_two_out() {
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()))
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(2000))
+        .capacity(capacity_bytes!(2000).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
     let output_cell2 = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -1029,19 +1032,19 @@ fn create_rtx_to_load_code_to_stack_then_reuse(
         vec.extend_from_slice(&flag.to_le_bytes());
         vec.extend_from_slice(&size.to_le_bytes());
         vec.extend_from_slice(&data_hash);
-        vec.into()
+        vec.pack()
     };
 
     let (dyn_lock_cell, dyn_lock_data_hash) =
         load_cell_from_path("testdata/load_code_to_stack_then_reuse");
 
     let dyn_lock_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(dyn_lock_data_hash)
         .args(args)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(dyn_lock_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1108,7 +1111,7 @@ fn check_debugger() {
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -1120,27 +1123,27 @@ fn check_debugger() {
     .build();
 
     let script = Script::new_builder()
-        .code_hash(blake2b_256(&buffer))
-        .hash_type(ScriptHashType::Data)
+        .code_hash(blake2b_256(&buffer).pack())
+        .hash_type(ScriptHashType::Data.into())
         .build();
     let output_data = Bytes::default();
     let output = CellOutputBuilder::default()
         .lock(
             Script::new_builder()
-                .hash_type(ScriptHashType::Data)
+                .hash_type(ScriptHashType::Data.into())
                 .build(),
         )
-        .type_(Some(script))
+        .type_(Some(script).pack())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let dep_cell = {
         let data = Bytes::from(buffer);
         let output = CellOutputBuilder::default()
-            .capacity(Capacity::bytes(data.len()).unwrap())
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
             .build();
         CellMetaBuilder::from_cell_output(output, data)
             .transaction_info(default_transaction_info())
@@ -1151,7 +1154,7 @@ fn check_debugger() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(output_data)
+        .output_data(output_data.pack())
         .cell_dep(cell_dep)
         .build();
 
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2021.rs b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
index 93e94557bc..cb70fb0b4c 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2021.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
@@ -28,11 +28,11 @@ fn test_hint_instructions() {
         load_cell_from_path("testdata/cadd_hint_lock");
 
     let always_success_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(always_success_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -73,18 +73,18 @@ fn test_b_extension() {
         let mut vec = Vec::with_capacity(8 * 2);
         vec.extend_from_slice(&num0.to_le_bytes());
         vec.extend_from_slice(&num1.to_le_bytes());
-        vec.into()
+        vec.pack()
     };
 
     let (cpop_lock_cell, cpop_lock_data_hash) = load_cell_from_path("testdata/cpop_lock");
 
     let cpop_lock_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(cpop_lock_data_hash)
         .args(args)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(cpop_lock_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -128,11 +128,11 @@ fn test_cycles_difference() {
         load_cell_from_path("testdata/mop_adc_lock");
 
     let always_success_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(always_success_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(always_success_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -167,11 +167,11 @@ fn check_current_cycles() {
         load_cell_from_path("testdata/current_cycles");
 
     let current_cycles_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(current_cycles_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(current_cycles_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -199,11 +199,11 @@ fn check_current_cycles_with_snapshot() {
         load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let current_cycles_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(current_cycles_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(current_cycles_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -244,11 +244,11 @@ fn check_vm_version() {
     let (vm_version_cell, vm_version_data_hash) = load_cell_from_path("testdata/vm_version");
 
     let vm_version_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -276,11 +276,11 @@ fn check_vm_version_with_snapshot() {
         load_cell_from_path("testdata/vm_version_with_snapshot");
 
     let vm_version_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -323,11 +323,11 @@ fn check_exec_from_cell_data() {
     let (exec_callee_cell, _exec_callee_data_hash) = load_cell_from_path("testdata/exec_callee");
 
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -356,11 +356,11 @@ fn check_exec_from_witness() {
     let (exec_callee_cell, _exec_caller_data_hash) = load_cell_from_path("testdata/exec_callee");
 
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -368,7 +368,7 @@ fn check_exec_from_witness() {
     let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
     let transaction = TransactionBuilder::default()
         .input(input)
-        .set_witnesses(vec![exec_callee_cell_data.into()])
+        .set_witnesses(vec![exec_callee_cell_data.pack()])
         .build();
     let dummy_cell = create_dummy_cell(output);
 
@@ -399,11 +399,11 @@ fn check_exec_wrong_callee_format() {
         load_cell_from_slice(&[0x00, 0x01, 0x02, 0x03]);
 
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -433,11 +433,11 @@ async fn async_check_exec_wrong_callee_format() {
         load_cell_from_slice(&[0x00, 0x01, 0x02, 0x03]);
 
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -469,11 +469,11 @@ fn check_exec_big_offset_length() {
         load_cell_from_slice(&[0x00, 0x01, 0x02, 0x03]);
 
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -500,25 +500,25 @@ fn _check_type_id_one_in_one_out_resume(step_cycles: Cycle) -> Result<(), TestCa
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()))
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script))
+        .type_(Some(type_id_script).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -650,25 +650,25 @@ fn _check_type_id_one_in_one_out_resume_with_state(
 
     let (always_success_cell, always_success_cell_data, always_success_script) =
         always_success_cell();
-    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()))
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000))
+        .capacity(capacity_bytes!(1000).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()))
+        .type_(Some(type_id_script.clone()).pack())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990))
+        .capacity(capacity_bytes!(990).pack())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script))
+        .type_(Some(type_id_script).pack())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -1045,19 +1045,19 @@ fn load_code_into_global() {
             let mut vec = Vec::with_capacity(8 + data_hash.len());
             vec.extend_from_slice(&number.to_le_bytes());
             vec.extend_from_slice(&data_hash);
-            vec.into()
+            vec.pack()
         };
 
         let (dyn_lock_cell, dyn_lock_data_hash) =
             load_cell_from_path("testdata/load_is_even_into_global");
 
         let dyn_lock_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type())
+            .hash_type(script_version.data_hash_type().into())
             .code_hash(dyn_lock_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(dyn_lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1101,19 +1101,19 @@ fn load_code_with_snapshot() {
             let mut vec = Vec::with_capacity(8 + data_hash.len());
             vec.extend_from_slice(&number.to_le_bytes());
             vec.extend_from_slice(&data_hash);
-            vec.into()
+            vec.pack()
         };
 
         let (dyn_lock_cell, dyn_lock_data_hash) =
             load_cell_from_path("testdata/load_is_even_with_snapshot");
 
         let dyn_lock_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type())
+            .hash_type(script_version.data_hash_type().into())
             .code_hash(dyn_lock_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(dyn_lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1202,16 +1202,16 @@ fn load_code_with_snapshot_more_times() {
             vec.extend_from_slice(&div2); // num0 = 3
             vec.extend_from_slice(&sub1); // num0 = 2
             vec.extend_from_slice(&div2); // num0 = 1
-            vec.into()
+            vec.pack()
         };
 
         let lock_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type())
+            .hash_type(script_version.data_hash_type().into())
             .code_hash(lock_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1330,7 +1330,7 @@ fn test_exec(
         vec.extend_from_slice(&place.to_le_bytes());
         vec.extend_from_slice(&bounds.to_le_bytes());
         vec.extend_from_slice(&data_hash);
-        vec.into()
+        vec.pack()
     };
 
     let rtx = {
@@ -1343,12 +1343,12 @@ fn test_exec(
             always_success_cell();
 
         let exec_caller_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type())
+            .hash_type(script_version.data_hash_type().into())
             .code_hash(exec_caller_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(exec_caller_script.clone())
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1360,7 +1360,7 @@ fn test_exec(
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let tx = TransactionBuilder::default()
                     .input(input)
-                    .set_witnesses(vec![exec_callee_cell_data.into()])
+                    .set_witnesses(vec![exec_callee_cell_data.pack()])
                     .build();
                 (tx, vec![create_dummy_cell(output)])
             }
@@ -1372,7 +1372,7 @@ fn test_exec(
 
                 let tx = TransactionBuilder::default()
                     .input(input)
-                    .set_witnesses(vec![data.into()])
+                    .set_witnesses(vec![data.pack()])
                     .build();
                 (tx, vec![create_dummy_cell(output)])
             }
@@ -1383,18 +1383,18 @@ fn test_exec(
             ExecFrom::GroupOutputWitness => {
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100))
-                    .type_(Some(exec_caller_script))
+                    .capacity(capacity_bytes!(100).pack())
+                    .type_(Some(exec_caller_script).pack())
                     .build();
                 let tx = TransactionBuilder::default()
                     .output(output)
-                    .set_witnesses(vec![exec_callee_cell_data.into()])
+                    .set_witnesses(vec![exec_callee_cell_data.pack()])
                     .build();
                 (tx, vec![])
             }
             ExecFrom::TxInputCell => {
                 let callee_output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(always_success_script.clone())
                     .build();
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
@@ -1407,9 +1407,9 @@ fn test_exec(
             }
             ExecFrom::GroupInputCell => {
                 let caller_output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100))
+                    .capacity(capacity_bytes!(100).pack())
                     .lock(exec_caller_script)
-                    .type_(Some(always_success_script.clone()))
+                    .type_(Some(always_success_script.clone()).pack())
                     .build();
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let caller_cell =
@@ -1422,38 +1422,38 @@ fn test_exec(
             ExecFrom::TxOutputCell => {
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let callee_output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100))
+                    .capacity(capacity_bytes!(100).pack())
                     .lock(always_success_script.clone())
                     .build();
                 let tx = TransactionBuilder::default()
                     .input(input)
                     .output(callee_output)
-                    .output_data(exec_callee_cell_data)
+                    .output_data(exec_callee_cell_data.pack())
                     .build();
                 (tx, vec![create_dummy_cell(output)])
             }
             ExecFrom::GroupOutputCell => {
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let callee_output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100))
-                    .type_(Some(exec_caller_script))
+                    .capacity(capacity_bytes!(100).pack())
+                    .type_(Some(exec_caller_script).pack())
                     .build();
                 let tx = TransactionBuilder::default()
                     .output(callee_output)
-                    .output_data(exec_callee_cell_data)
+                    .output_data(exec_callee_cell_data.pack())
                     .build();
                 (tx, vec![])
             }
             ExecFrom::OutOfBound(..) => {
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let tx = TransactionBuilder::default()
-                    .set_witnesses(vec![exec_callee_cell_data.into()])
+                    .set_witnesses(vec![exec_callee_cell_data.pack()])
                     .build();
                 (tx, vec![create_dummy_cell(output)])
             }
         };
 
-        let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
+        let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
         let resolved_always_success_cell = CellMetaBuilder::from_cell_output(
             always_success_cell.clone(),
             always_success_cell_data.to_owned(),
@@ -1793,18 +1793,21 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
     args.extend(&to_hex_pubkey(&pubkey));
     args.extend(&to_hex_signature(&signature));
 
-    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap())
-        .type_(Some(
-            Script::new_builder()
-                .code_hash(h256!("0x123456abcd90"))
-                .hash_type(ScriptHashType::Data)
-                .build(),
-        ))
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
+        .type_(
+            Some(
+                Script::new_builder()
+                    .code_hash(h256!("0x123456abcd90").pack())
+                    .hash_type(ScriptHashType::Data.into())
+                    .build(),
+            )
+            .pack(),
+        )
         .build();
     let type_hash = output.type_().to_opt().as_ref().unwrap().calc_script_hash();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data.clone())
@@ -1812,18 +1815,21 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .out_point(dep_out_point)
         .build();
 
-    let dep_out_point2 = OutPoint::new(h256!("0x1234").into(), 8);
+    let dep_out_point2 = OutPoint::new(h256!("0x1234").pack(), 8);
     let cell_dep2 = CellDep::new_builder()
         .out_point(dep_out_point2.clone())
         .build();
     let output2 = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap())
-        .type_(Some(
-            Script::new_builder()
-                .code_hash(h256!("0x123456abcd90"))
-                .hash_type(ScriptHashType::Data)
-                .build(),
-        ))
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
+        .type_(
+            Some(
+                Script::new_builder()
+                    .code_hash(h256!("0x123456abcd90").pack())
+                    .hash_type(ScriptHashType::Data.into())
+                    .build(),
+            )
+            .pack(),
+        )
         .build();
     let dep_cell2 = CellMetaBuilder::from_cell_output(output2, data)
         .transaction_info(default_transaction_info())
@@ -1831,9 +1837,9 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args))
+        .args(Bytes::from(args).pack())
         .code_hash(type_hash)
-        .hash_type(ScriptHashType::Type)
+        .hash_type(ScriptHashType::Type.into())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -1844,7 +1850,7 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -1874,11 +1880,11 @@ fn check_exec_callee_pause() {
         load_cell_from_path("testdata/exec_callee_pause");
 
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2023.rs b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
index e44809e783..4cb4fd8583 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2023.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
@@ -14,12 +14,12 @@ fn simple_spawn_test(bin_path: &str, args: &[u8]) -> Result<Cycle, Error> {
 
     let (cell, data_hash) = load_cell_from_path(bin_path);
     let script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(data_hash)
-        .args(Bytes::copy_from_slice(args))
+        .args(Bytes::copy_from_slice(args).pack())
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -116,11 +116,11 @@ fn check_vm_version() {
     let (vm_version_cell, vm_version_data_hash) = load_cell_from_path("testdata/vm_version_2");
 
     let vm_version_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -150,10 +150,11 @@ fn check_spawn_strcat() {
         load_cell_from_path("testdata/spawn_callee_strcat");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -182,11 +183,11 @@ fn check_spawn_out_of_cycles() {
         load_cell_from_path("testdata/spawn_callee_out_of_cycles");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -222,11 +223,11 @@ fn check_spawn_exec() {
     let (spawn_callee_callee_cell, _) = load_cell_from_path("testdata/spawn_callee_exec_callee");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -259,11 +260,11 @@ fn check_spawn_strcat_wrap() {
     let (spawn_callee_callee_cell, _) = load_cell_from_path("testdata/spawn_callee_strcat");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -296,11 +297,11 @@ fn check_spawn_out_of_cycles_wrap() {
     let (spawn_callee_callee_cell, _) = load_cell_from_path("testdata/spawn_callee_out_of_cycles");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -338,11 +339,11 @@ fn check_spawn_recursive() {
         load_cell_from_path("testdata/spawn_recursive");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -378,11 +379,11 @@ fn check_spawn_snapshot() {
     let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -419,11 +420,11 @@ async fn check_spawn_async() {
     let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -498,11 +499,11 @@ async fn check_spawn_suspend_shutdown() {
     let (snapshot_cell, _) = load_cell_from_path("testdata/infinite_loop");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -555,11 +556,11 @@ fn check_spawn_state() {
     let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -623,11 +624,11 @@ fn check_spawn_current_cycles() {
         load_cell_from_path("testdata/spawn_callee_current_cycles");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -700,19 +701,18 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
         load_cell_from_path("testdata/always_success");
     let spawn_callee_cell_data = spawn_callee_cell.mem_cell_data.as_ref().unwrap();
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
-        .args(args)
+        .args(args.pack())
         .build();
-
     let always_success_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(always_success_data_hash)
         .build();
 
     let input_spawn_caller = create_dummy_cell(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(spawn_caller_script.clone())
             .build(),
     );
@@ -721,7 +721,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
         SpawnFrom::TxInputWitness | SpawnFrom::TxOutputWitness | SpawnFrom::GroupInputWitness => {
             ResolvedTransaction {
                 transaction: TransactionBuilder::default()
-                    .set_witnesses(vec![spawn_callee_cell_data.into()])
+                    .set_witnesses(vec![spawn_callee_cell_data.pack()])
                     .build(),
                 resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
                 resolved_inputs: vec![input_spawn_caller],
@@ -732,11 +732,11 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             transaction: TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(100))
-                        .type_(Some(spawn_caller_script))
+                        .capacity(capacity_bytes!(100).pack())
+                        .type_(Some(spawn_caller_script).pack())
                         .build(),
                 )
-                .set_witnesses(vec![spawn_callee_cell_data.into()])
+                .set_witnesses(vec![spawn_callee_cell_data.pack()])
                 .build(),
             resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
             resolved_inputs: vec![],
@@ -750,7 +750,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
         },
         SpawnFrom::TxInputCell => {
             let input_spawn_callee_output = CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(always_success_script)
                 .build();
             let input_spawn_callee = CellMetaBuilder::from_cell_output(
@@ -769,11 +769,11 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             transaction: TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(100))
+                        .capacity(capacity_bytes!(100).pack())
                         .lock(always_success_script)
                         .build(),
                 )
-                .output_data(spawn_callee_cell_data)
+                .output_data(spawn_callee_cell_data.pack())
                 .build(),
             resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
             resolved_inputs: vec![input_spawn_caller],
@@ -782,7 +782,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
         SpawnFrom::GroupInputCell => {
             let input_spawn_caller = CellMetaBuilder::from_cell_output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100))
+                    .capacity(capacity_bytes!(100).pack())
                     .lock(spawn_caller_script)
                     .build(),
                 spawn_callee_cell_data.clone(),
@@ -799,11 +799,11 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             transaction: TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(100))
-                        .type_(Some(spawn_caller_script))
+                        .capacity(capacity_bytes!(100).pack())
+                        .type_(Some(spawn_caller_script).pack())
                         .build(),
                 )
-                .output_data(spawn_callee_cell_data)
+                .output_data(spawn_callee_cell_data.pack())
                 .build(),
             resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
             resolved_inputs: vec![],
@@ -817,7 +817,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             }
             ResolvedTransaction {
                 transaction: TransactionBuilder::default()
-                    .set_witnesses(vec![data.into()])
+                    .set_witnesses(vec![data.pack()])
                     .build(),
                 resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
                 resolved_inputs: vec![input_spawn_caller],
@@ -1130,17 +1130,17 @@ proptest! {
 
         let (code_dep, code_dep_hash) = load_cell_from_slice(&program[..]);
         let spawn_caller_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type() )
+            .hash_type(script_version.data_hash_type().into())
             .code_hash(code_dep_hash)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100) )
+            .capacity(capacity_bytes!(100).pack())
             .lock(spawn_caller_script)
             .build();
         let dummy_cell = create_dummy_cell(output);
 
         let rtx = ResolvedTransaction {
-            transaction: TransactionBuilder::default().witness(data.as_bytes()).build(),
+            transaction: TransactionBuilder::default().witness(data.as_bytes().pack()).build(),
             resolved_cell_deps: vec![code_dep],
             resolved_inputs: vec![dummy_cell],
             resolved_dep_groups: vec![],
@@ -1190,11 +1190,11 @@ fn check_spawn_huge_swap() {
         load_cell_from_path("testdata/spawn_huge_swap");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1243,11 +1243,11 @@ fn check_spawn_cycles() {
     let (spawn_callee_cell, _spawn_callee_data_hash) = load_cell_from_path("testdata/spawn_cycles");
 
     let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1278,12 +1278,12 @@ fn spawn_io_test(io_size: u64, enable_check: bool) -> Result<u64, Error> {
 
     let (cell, data_hash) = load_cell_from_path("testdata/spawn_io_cycles");
     let script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(data_hash)
-        .args(Bytes::copy_from_slice(&args))
+        .args(Bytes::copy_from_slice(&args).pack())
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1333,11 +1333,11 @@ fn check_infinite_exec() {
 
     let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/infinite_exec");
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1370,11 +1370,11 @@ fn check_fuzz_crash_1() {
 
     let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/crash-5a27052f");
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1408,11 +1408,11 @@ fn check_fuzz_crash_2() {
     let script_version = SCRIPT_VERSION;
     let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/crash-45a6098d");
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1441,11 +1441,11 @@ fn check_fuzz_crash_3() {
     let script_version = SCRIPT_VERSION;
     let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/crash-4717eb0e");
     let exec_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type())
+        .hash_type(script_version.data_hash_type().into())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
diff --git a/script/src/verify/tests/utils.rs b/script/src/verify/tests/utils.rs
index 97ff7f6740..760921f627 100644
--- a/script/src/verify/tests/utils.rs
+++ b/script/src/verify/tests/utils.rs
@@ -22,7 +22,7 @@ use ckb_types::{
     },
     h256,
     packed::{
-        self, Byte32, CellDep, CellInput, OutPoint, Script, TransactionInfoBuilder,
+        Byte32, CellDep, CellInput, OutPoint, Script, TransactionInfoBuilder,
         TransactionKeyBuilder, WitnessArgs,
     },
     H256,
@@ -67,7 +67,7 @@ pub(crate) fn load_cell_from_path(path_str: &str) -> (CellMeta, Byte32) {
 pub(crate) fn load_cell_from_slice(slice: &[u8]) -> (CellMeta, Byte32) {
     let cell_data = Bytes::copy_from_slice(slice);
     let cell_output = CellOutput::new_builder()
-        .capacity(Capacity::bytes(cell_data.len()).unwrap())
+        .capacity(Capacity::bytes(cell_data.len()).unwrap().pack())
         .build();
     let cell_meta = CellMetaBuilder::from_cell_output(cell_output, cell_data)
         .transaction_info(default_transaction_info())
@@ -107,16 +107,16 @@ pub(crate) fn sign_args(args: &[u8], privkey: &Privkey) -> Signature {
 
 pub(crate) fn default_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64)
-        .block_epoch(0u64)
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32)
+                .index(1u32.pack())
                 .build(),
         )
         .build()
-        .into()
+        .unpack()
 }
 
 pub(crate) struct TransactionScriptsVerifierWithEnv {
@@ -184,7 +184,9 @@ impl TransactionScriptsVerifierWithEnv {
             ScriptVersion::V1 => EpochNumberWithFraction::new(self.version_1_enabled_at, 0, 1),
             ScriptVersion::V2 => EpochNumberWithFraction::new(self.version_2_enabled_at, 0, 1),
         };
-        let header = HeaderView::new_advanced_builder().epoch(epoch).build();
+        let header = HeaderView::new_advanced_builder()
+            .epoch(epoch.pack())
+            .build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
@@ -273,7 +275,9 @@ impl TransactionScriptsVerifierWithEnv {
             ScriptVersion::V1 => EpochNumberWithFraction::new(self.version_1_enabled_at, 0, 1),
             ScriptVersion::V2 => EpochNumberWithFraction::new(self.version_2_enabled_at, 0, 1),
         };
-        let header = HeaderView::new_advanced_builder().epoch(epoch).build();
+        let header = HeaderView::new_advanced_builder()
+            .epoch(epoch.pack())
+            .build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
@@ -305,7 +309,9 @@ impl TransactionScriptsVerifierWithEnv {
             ScriptVersion::V1 => EpochNumberWithFraction::new(self.version_1_enabled_at, 0, 1),
             ScriptVersion::V2 => EpochNumberWithFraction::new(self.version_2_enabled_at, 0, 1),
         };
-        let header = HeaderView::new_advanced_builder().epoch(epoch).build();
+        let header = HeaderView::new_advanced_builder()
+            .epoch(epoch.pack())
+            .build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let mut verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
@@ -330,11 +336,11 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
 
     let cell_dep = CellDep::new_builder()
         .out_point(secp_out_point)
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
 
-    let input1 = CellInput::new(OutPoint::new(h256!("0x1234").into(), 0), 0);
-    let input2 = CellInput::new(OutPoint::new(h256!("0x1111").into(), 0), 0);
+    let input1 = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 0), 0);
+    let input2 = CellInput::new(OutPoint::new(h256!("0x1111").pack(), 0), 0);
 
     let mut generator = Generator::non_crypto_safe_prng(42);
     let privkey = generator.gen_privkey();
@@ -345,23 +351,23 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
     let lock_arg2 = Bytes::from((blake2b_256(pubkey_data2)[0..20]).to_owned());
 
     let lock = Script::new_builder()
-        .args(lock_arg)
-        .code_hash(type_lock_script_code_hash())
-        .hash_type(ScriptHashType::Type)
+        .args(lock_arg.pack())
+        .code_hash(type_lock_script_code_hash().pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
     let lock2 = Script::new_builder()
-        .args(lock_arg2)
-        .code_hash(type_lock_script_code_hash())
-        .hash_type(ScriptHashType::Type)
+        .args(lock_arg2.pack())
+        .code_hash(type_lock_script_code_hash().pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output1 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(lock.clone())
         .build();
     let output2 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(lock2.clone())
         .build();
     let tx = TransactionBuilder::default()
@@ -370,15 +376,15 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .input(input2.clone())
         .output(output1)
         .output(output2)
-        .output_data(packed::Bytes::default())
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
+        .output_data(Default::default())
         .build();
 
-    let tx_hash: H256 = tx.hash().into();
+    let tx_hash: H256 = tx.hash().unpack();
     // sign input1
     let witness = {
         WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])))
+            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
             .build()
     };
     let witness_len: u64 = witness.as_bytes().len() as u64;
@@ -393,11 +399,11 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
     };
     let sig = privkey.sign_recoverable(&message).expect("sign");
     let witness = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(sig.serialize())))
+        .lock(Some(Bytes::from(sig.serialize())).pack())
         .build();
     // sign input2
     let witness2 = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])))
+        .lock(Some(Bytes::from(vec![0u8; 65])).pack())
         .build();
     let witness2_len: u64 = witness2.as_bytes().len() as u64;
     let mut hasher = new_blake2b();
@@ -411,12 +417,12 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
     };
     let sig2 = privkey2.sign_recoverable(&message2).expect("sign");
     let witness2 = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(sig2.serialize())))
+        .lock(Some(Bytes::from(sig2.serialize())).pack())
         .build();
     let tx = tx
         .as_advanced_builder()
-        .witness(witness.as_bytes())
-        .witness(witness2.as_bytes())
+        .witness(witness.as_bytes().pack())
+        .witness(witness2.as_bytes().pack())
         .build();
 
     let serialized_size = tx.data().as_slice().len() as u64;
@@ -432,7 +438,7 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
     let (secp256k1_data_cell, secp256k1_data_cell_data) = secp256k1_data_cell(consensus);
 
     let input_cell1 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(lock)
         .build();
 
@@ -441,7 +447,7 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .build();
 
     let input_cell2 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(lock2)
         .build();
 
diff --git a/shared/src/shared.rs b/shared/src/shared.rs
index 9687165186..2939230a5f 100644
--- a/shared/src/shared.rs
+++ b/shared/src/shared.rs
@@ -220,7 +220,7 @@ impl Shared {
                     e
                 })?;
 
-                let pack_number: packed::Uint64 = number.into();
+                let pack_number: packed::Uint64 = number.pack();
                 let prefix = pack_number.as_slice();
                 for (key, value) in snapshot
                     .get_iter(
@@ -233,7 +233,7 @@ impl Shared {
                     let block_hash = reader.block_hash().to_entity();
                     if &block_hash != hash {
                         let txs =
-                            packed::Uint32Reader::from_slice_should_be_ok(value.as_ref()).into();
+                            packed::Uint32Reader::from_slice_should_be_ok(value.as_ref()).unpack();
                         side.insert(block_hash, (reader.number().to_entity(), txs));
                     }
                 }
@@ -254,10 +254,12 @@ impl Shared {
         if !side.is_empty() {
             // Wipe out side chain
             for (hash, (number, txs)) in &side {
-                batch.delete_block(number.into(), hash, *txs).map_err(|e| {
-                    ckb_logger::error!("Freezer delete_block_body failed {}", e);
-                    e
-                })?;
+                batch
+                    .delete_block(number.unpack(), hash, *txs)
+                    .map_err(|e| {
+                        ckb_logger::error!("Freezer delete_block_body failed {}", e);
+                        e
+                    })?;
             }
 
             self.store.write(&batch).map_err(|e| {
@@ -277,12 +279,12 @@ impl Shared {
     fn compact_block_body(&self, start: &packed::Byte32, end: &packed::Byte32) {
         let start_t = packed::TransactionKey::new_builder()
             .block_hash(start.clone())
-            .index(0u32)
+            .index(0u32.pack())
             .build();
 
         let end_t = packed::TransactionKey::new_builder()
             .block_hash(end.clone())
-            .index(TX_INDEX_UPPER_BOUND)
+            .index(TX_INDEX_UPPER_BOUND.pack())
             .build();
 
         if let Err(e) = self.store.compact_range(
diff --git a/shared/src/shared_builder.rs b/shared/src/shared_builder.rs
index 1bb7537d31..155a564a0f 100644
--- a/shared/src/shared_builder.rs
+++ b/shared/src/shared_builder.rs
@@ -22,6 +22,7 @@ use ckb_tx_pool::{
     service::TxVerificationResult, TokioRwLock, TxEntry, TxPool, TxPoolServiceBuilder,
 };
 use ckb_types::core::hardfork::HardForks;
+use ckb_types::prelude::Pack;
 use ckb_types::{
     core::service::PoolTransactionEntry, core::tx_pool::Reject, core::EpochExt, core::HeaderView,
 };
@@ -343,7 +344,7 @@ impl SharedBuilder {
         snapshot: &Snapshot,
     ) -> bool {
         if let Some(ref target) = sync_config.assume_valid_target {
-            if snapshot.block_exists(&target.into()) {
+            if snapshot.block_exists(&target.pack()) {
                 info!("assume valid target is already in db, CKB will do full verification from now on");
                 return true;
             }
diff --git a/spec/src/consensus.rs b/spec/src/consensus.rs
index 83f9b29af9..2d8a16c481 100644
--- a/spec/src/consensus.rs
+++ b/spec/src/consensus.rs
@@ -168,13 +168,13 @@ impl Default for ConsensusBuilder {
             let occupied = empty_output
                 .occupied_capacity(Capacity::zero())
                 .expect("default occupied");
-            empty_output.as_builder().capacity(occupied).build()
+            empty_output.as_builder().capacity(occupied.pack()).build()
         };
         let witness = Script::default().into_witness();
         let cellbase = TransactionBuilder::default()
             .input(input)
             .output(output)
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .witness(witness)
             .build();
 
@@ -200,8 +200,8 @@ impl Default for ConsensusBuilder {
         .expect("genesis dao data calculation error!");
 
         let genesis_block = BlockBuilder::default()
-            .compact_target(DIFF_TWO)
-            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0))
+            .compact_target(DIFF_TWO.pack())
+            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).pack())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -964,7 +964,7 @@ impl Consensus {
 
     /// The network identify name, used for network identify protocol
     pub fn identify_name(&self) -> String {
-        let genesis_hash = format!("{:x}", Into::<H256>::into(&self.genesis_hash));
+        let genesis_hash = format!("{:x}", Unpack::<H256>::unpack(&self.genesis_hash));
         format!("/{}/{}", self.id, &genesis_hash[..8])
     }
 
@@ -1145,14 +1145,14 @@ impl From<Consensus> for ckb_jsonrpc_types::Consensus {
         };
         Self {
             id: consensus.id,
-            genesis_hash: consensus.genesis_hash.into(),
-            dao_type_hash: consensus.dao_type_hash.into(),
+            genesis_hash: consensus.genesis_hash.unpack(),
+            dao_type_hash: consensus.dao_type_hash.unpack(),
             secp256k1_blake160_sighash_all_type_hash: consensus
                 .secp256k1_blake160_sighash_all_type_hash
-                .map(|h| h.into()),
+                .map(|h| h.unpack()),
             secp256k1_blake160_multisig_all_type_hash: consensus
                 .secp256k1_blake160_multisig_all_type_hash
-                .map(|h| h.into()),
+                .map(|h| h.unpack()),
             initial_primary_epoch_reward: consensus.initial_primary_epoch_reward.into(),
             secondary_epoch_reward: consensus.secondary_epoch_reward.into(),
             max_uncles_num: (consensus.max_uncles_num as u64).into(),
diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index 588aa4657d..4e029bc6cb 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -500,7 +500,7 @@ impl ChainSpec {
 
     fn verify_genesis_hash(&self, genesis: &BlockView) -> Result<(), Box<dyn Error>> {
         if let Some(ref expect) = self.genesis.hash {
-            let actual: H256 = genesis.hash().into();
+            let actual: H256 = genesis.hash().unpack();
             if &actual != expect {
                 return Err(SpecLoadError::genesis_mismatch(expect.clone(), actual));
             }
@@ -609,7 +609,7 @@ impl ChainSpec {
                 .raw()
                 .outputs()
                 .iter()
-                .map(|output| Into::<Capacity>::into(output.capacity()))
+                .map(|output| Unpack::<Capacity>::unpack(&output.capacity()))
                 .try_fold(Capacity::zero(), Capacity::safe_add)
         }?;
 
@@ -633,14 +633,14 @@ impl ChainSpec {
         );
 
         let block = BlockBuilder::default()
-            .version(self.genesis.version)
-            .parent_hash(&self.genesis.parent_hash)
-            .timestamp(self.genesis.timestamp)
-            .compact_target(self.genesis.compact_target)
-            .extra_hash(&self.genesis.uncles_hash)
-            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0))
+            .version(self.genesis.version.pack())
+            .parent_hash(self.genesis.parent_hash.pack())
+            .timestamp(self.genesis.timestamp.pack())
+            .compact_target(self.genesis.compact_target.pack())
+            .extra_hash(self.genesis.uncles_hash.pack())
+            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).pack())
             .dao(dao)
-            .nonce(u128::from_le_bytes(self.genesis.nonce.to_le_bytes()))
+            .nonce(u128::from_le_bytes(self.genesis.nonce.to_le_bytes()).pack())
             .transaction(cellbase_transaction)
             .transaction(dep_group_transaction)
             .build();
@@ -734,7 +734,7 @@ impl ChainSpec {
 
         // Check system cells data hash
         let check_cells_data_hash = |tx_index, output_index, hash: &H256| {
-            if data_hashes.get(&hash.into()) != Some(&(tx_index, output_index)) {
+            if data_hashes.get(&hash.pack()) != Some(&(tx_index, output_index)) {
                 return Err(format!(
                     "Invalid output data for tx-index: {tx_index}, output-index: {output_index}, expected data hash: {hash:x}",
                 ));
@@ -801,12 +801,12 @@ impl ChainSpec {
         outputs_data.extend(system_cells_data);
 
         let special_issued_lock = packed::Script::new_builder()
-            .args(secp_lock_arg(&Privkey::from(SPECIAL_CELL_PRIVKEY.clone())))
-            .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone())
-            .hash_type(ScriptHashType::Data)
+            .args(secp_lock_arg(&Privkey::from(SPECIAL_CELL_PRIVKEY.clone())).pack())
+            .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone().pack())
+            .hash_type(ScriptHashType::Data.into())
             .build();
         let special_issued_cell = packed::CellOutput::new_builder()
-            .capacity(special_cell_capacity)
+            .capacity(special_cell_capacity.pack())
             .lock(special_issued_lock)
             .build();
         outputs.push(special_issued_cell);
@@ -829,7 +829,7 @@ impl ChainSpec {
             .outputs_data(
                 outputs_data
                     .iter()
-                    .map(|d| d.into())
+                    .map(|d| d.pack())
                     .collect::<Vec<packed::Bytes>>(),
             )
             .build();
@@ -872,11 +872,11 @@ impl ChainSpec {
                     })
                     .collect::<Result<_, Box<dyn Error>>>()?;
 
-                let data = Into::<packed::OutPointVec>::into(out_points).as_bytes();
+                let data = out_points.pack().as_bytes();
                 let cell = packed::CellOutput::new_builder()
-                    .lock(self.genesis.system_cells_lock.clone())
+                    .lock(self.genesis.system_cells_lock.clone().into())
                     .build_exact_capacity(Capacity::bytes(data.len())?)?;
-                Ok((cell, data.into()))
+                Ok((cell, data.pack()))
             })
             .collect::<Result<Vec<(packed::CellOutput, packed::Bytes)>, Box<dyn Error>>>()?
             .into_iter()
@@ -887,17 +887,17 @@ impl ChainSpec {
         let input_out_point = cellbase_tx
             .outputs()
             .into_iter()
-            .position(|output| Into::<Bytes>::into(output.lock().args()) == lock_arg)
+            .position(|output| Unpack::<Bytes>::unpack(&output.lock().args()) == lock_arg)
             .map(|index| packed::OutPoint::new(cellbase_tx.hash(), index as u32))
             .expect("Get special issued input failed");
         let input = packed::CellInput::new(input_out_point, 0);
 
         let secp_data_out_point =
-            find_out_point_by_data_hash(cellbase_tx, &CODE_HASH_SECP256K1_DATA.into())
+            find_out_point_by_data_hash(cellbase_tx, &CODE_HASH_SECP256K1_DATA.pack())
                 .ok_or_else(|| String::from("Get secp data out point failed"))?;
         let secp_blake160_out_point = find_out_point_by_data_hash(
             cellbase_tx,
-            &CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.into(),
+            &CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.pack(),
         )
         .ok_or_else(|| String::from("Get secp blake160 out point failed"))?;
         let cell_deps = vec![
@@ -915,10 +915,10 @@ impl ChainSpec {
             .outputs_data(outputs_data.clone())
             .build();
 
-        let tx_hash: H256 = tx.hash().into();
+        let tx_hash: H256 = tx.hash().unpack();
         let message = H256::from(blake2b_256(tx_hash));
         let sig = privkey.sign_recoverable(&message).expect("sign");
-        let witness = Bytes::from(sig.serialize());
+        let witness = Bytes::from(sig.serialize()).pack();
 
         Ok(TransactionBuilder::default()
             .cell_deps(cell_deps)
@@ -934,7 +934,7 @@ impl GenesisCell {
     fn build_output(&self) -> Result<(packed::CellOutput, Bytes), Box<dyn Error>> {
         let data: Bytes = self.message.as_bytes().to_owned().into();
         let cell = packed::CellOutput::new_builder()
-            .lock(self.lock.clone())
+            .lock(self.lock.clone().into())
             .build_exact_capacity(Capacity::bytes(data.len())?)?;
         Ok((cell, data))
     }
@@ -943,8 +943,8 @@ impl GenesisCell {
 impl IssuedCell {
     fn build_output(&self) -> packed::CellOutput {
         packed::CellOutput::new_builder()
-            .lock(self.lock.clone())
-            .capacity(self.capacity)
+            .lock(self.lock.clone().into())
+            .capacity(self.capacity.pack())
             .build()
     }
 }
@@ -963,12 +963,12 @@ impl SystemCell {
             None
         };
         let builder = packed::CellOutput::new_builder()
-            .type_(type_script)
-            .lock(lock.clone());
+            .type_(type_script.pack())
+            .lock(lock.clone().into());
 
         let data_len = Capacity::bytes(data.len())?;
         let cell = if let Some(capacity) = self.capacity {
-            let cell = builder.capacity(capacity).build();
+            let cell = builder.capacity(capacity.pack()).build();
             let occupied_capacity = cell.occupied_capacity(data_len)?.as_u64();
             if occupied_capacity > capacity {
                 return Err(format!(
@@ -1004,9 +1004,9 @@ pub(crate) fn build_type_id_script(input: &packed::CellInput, output_index: u64)
     blake2b.finalize(&mut ret);
     let script_arg = Bytes::from(ret.to_vec());
     packed::Script::new_builder()
-        .code_hash(TYPE_ID_CODE_HASH)
-        .hash_type(ScriptHashType::Type)
-        .args(script_arg)
+        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(script_arg.pack())
         .build()
 }
 
diff --git a/spec/src/tests/consensus.rs b/spec/src/tests/consensus.rs
index 4cbec57011..eaa250ad76 100644
--- a/spec/src/tests/consensus.rs
+++ b/spec/src/tests/consensus.rs
@@ -5,6 +5,7 @@ use ckb_types::{
         HeaderView, TransactionBuilder,
     },
     packed::{Byte32, Bytes},
+    prelude::*,
     utilities::DIFF_TWO,
 };
 
@@ -52,8 +53,8 @@ fn test_halving_epoch_reward() {
 
     let header = |epoch: &EpochExt, number: u64| {
         HeaderBuilder::default()
-            .number(number)
-            .epoch(epoch.number_with_fraction(number))
+            .number(number.pack())
+            .epoch(epoch.number_with_fraction(number).pack())
             .build()
     };
 
diff --git a/spec/src/tests/mod.rs b/spec/src/tests/mod.rs
index e5f23bb5b7..ad621c1597 100644
--- a/spec/src/tests/mod.rs
+++ b/spec/src/tests/mod.rs
@@ -69,7 +69,7 @@ fn test_bundled_specs() {
         let consensus = consensus.unwrap();
         let block = consensus.genesis_block();
         let cellbase = block.transaction(0).unwrap();
-        let cellbase_hash: H256 = cellbase.hash().into();
+        let cellbase_hash: H256 = cellbase.hash().unpack();
 
         assert_eq!(spec_hashes.cellbase, cellbase_hash);
 
@@ -86,11 +86,11 @@ fn test_bundled_specs() {
             )
             .enumerate()
         {
-            let data_hash: H256 = packed::CellOutput::calc_data_hash(&data.raw_data()).into();
+            let data_hash: H256 = packed::CellOutput::calc_data_hash(&data.raw_data()).unpack();
             let type_hash: Option<H256> = output
                 .type_()
                 .to_opt()
-                .map(|script| script.calc_script_hash().into());
+                .map(|script| script.calc_script_hash().unpack());
             assert_eq!(index_minus_one + 1, cell.index, "{bundled_spec_err}");
             assert_eq!(cell.data_hash, data_hash, "{bundled_spec_err}");
             assert_eq!(cell.type_hash, type_hash, "{bundled_spec_err}");
@@ -106,11 +106,11 @@ fn test_bundled_specs() {
             .output(dep_group_tx_input_index)
             .unwrap()
             .capacity()
-            .into();
+            .unpack();
         let outputs_capacity = dep_group_tx
             .outputs()
             .into_iter()
-            .map(|output| Into::<Capacity>::into(&output.capacity()))
+            .map(|output| Unpack::<Capacity>::unpack(&output.capacity()))
             .try_fold(Capacity::zero(), Capacity::safe_add)
             .unwrap();
         // capacity for input and outputs should be same
@@ -130,7 +130,7 @@ fn test_bundled_specs() {
             let dep_group = &spec_hashes.dep_groups[i];
 
             // check the tx hashes of dep groups in spec file
-            let tx_hash = Into::<packed::Byte32>::into(&dep_group.tx_hash);
+            let tx_hash = dep_group.tx_hash.pack();
             assert_eq!(tx_hash, dep_group_tx.hash(), "{bundled_spec_err}");
 
             let out_point_vec = packed::OutPointVec::from_slice(&output_data.raw_data()).unwrap();
@@ -148,7 +148,7 @@ fn test_bundled_specs() {
                 // dep groups out_point should point to cellbase
                 assert_eq!(cellbase.hash(), out_point.tx_hash(), "{bundled_spec_err}");
 
-                let index_in_cellbase: usize = out_point.index().into();
+                let index_in_cellbase: usize = out_point.index().unpack();
 
                 // check index for included cells in dep groups
                 assert_eq!(
diff --git a/spec/src/tests/versionbits.rs b/spec/src/tests/versionbits.rs
index 898a17b97a..bcbb3aea57 100644
--- a/spec/src/tests/versionbits.rs
+++ b/spec/src/tests/versionbits.rs
@@ -162,8 +162,8 @@ impl MockChain {
         let cellbase = TransactionBuilder::default().build();
         BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .number((parent.number() + 1).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
             .transaction(cellbase)
             .build()
     }
@@ -175,16 +175,16 @@ impl MockChain {
         let version = self.compute_versionbits(parent).unwrap();
 
         let cellbase_witness = CellbaseWitness::new_builder()
-            .message(version.to_le_bytes().as_slice())
+            .message(version.to_le_bytes().as_slice().pack())
             .build();
 
-        let witness = cellbase_witness.as_bytes();
+        let witness = cellbase_witness.as_bytes().pack();
         let cellbase = TransactionBuilder::default().witness(witness).build();
 
         BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .number((parent.number() + 1).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
             .transaction(cellbase)
             .build()
     }
@@ -208,7 +208,7 @@ fn test_versionbits_active() {
         DEFAULT_ORPHAN_RATE_TARGET,
     );
     let genesis = BlockBuilder::default()
-        .epoch(epoch_ext.number_with_fraction(0))
+        .epoch(epoch_ext.number_with_fraction(0).pack())
         .transaction(cellbase)
         .build();
 
@@ -316,7 +316,7 @@ fn test_versionbits_failed() {
         DEFAULT_ORPHAN_RATE_TARGET,
     );
     let genesis = BlockBuilder::default()
-        .epoch(epoch_ext.number_with_fraction(0))
+        .epoch(epoch_ext.number_with_fraction(0).pack())
         .transaction(cellbase)
         .build();
 
diff --git a/store/src/cell.rs b/store/src/cell.rs
index 182fb06459..88c6e49e17 100644
--- a/store/src/cell.rs
+++ b/store/src/cell.rs
@@ -41,23 +41,23 @@ pub fn attach_block_cell(txn: &StoreTransaction, block: &BlockView) -> Result<()
                 .map(move |(index, (cell_output, data))| {
                     let out_point = packed::OutPoint::new_builder()
                         .tx_hash(tx_hash.clone())
-                        .index(index)
+                        .index(index.pack())
                         .build();
 
                     let entry = packed::CellEntryBuilder::default()
                         .output(cell_output)
                         .block_hash(block_hash.clone())
-                        .block_number(block_number)
-                        .block_epoch(block_epoch)
-                        .index(tx_index)
-                        .data_size(data.len() as u64)
+                        .block_number(block_number.pack())
+                        .block_epoch(block_epoch.pack())
+                        .index(tx_index.pack())
+                        .data_size((data.len() as u64).pack())
                         .build();
 
                     let data_entry = if !data.is_empty() {
                         let data_hash = packed::CellOutput::calc_data_hash(&data);
                         Some(
                             packed::CellDataEntryBuilder::default()
-                                .output_data(data)
+                                .output_data(data.pack())
                                 .output_data_hash(data_hash)
                                 .build(),
                         )
@@ -89,7 +89,7 @@ pub fn detach_block_cell(txn: &StoreTransaction, block: &BlockView) -> Result<()
     for tx in transactions.iter().skip(1) {
         for pts in tx.input_pts_iter() {
             let tx_hash = pts.tx_hash();
-            let index: usize = pts.index().into();
+            let index: usize = pts.index().unpack();
             let indexes = input_pts.entry(tx_hash).or_insert_with(Vec::new);
             indexes.push(index);
         }
@@ -111,23 +111,23 @@ pub fn detach_block_cell(txn: &StoreTransaction, block: &BlockView) -> Result<()
                         tx.output_with_data(*index).map(|(cell_output, data)| {
                             let out_point = packed::OutPoint::new_builder()
                                 .tx_hash(tx_hash.clone())
-                                .index(index)
+                                .index(index.pack())
                                 .build();
 
                             let entry = packed::CellEntryBuilder::default()
                                 .output(cell_output)
                                 .block_hash(block_hash.clone())
-                                .block_number(block_number)
-                                .block_epoch(block_epoch)
-                                .index(tx_index)
-                                .data_size(data.len() as u64)
+                                .block_number(block_number.pack())
+                                .block_epoch(block_epoch.pack())
+                                .index(tx_index.pack())
+                                .data_size((data.len() as u64).pack())
                                 .build();
 
                             let data_entry = if !data.is_empty() {
                                 let data_hash = packed::CellOutput::calc_data_hash(&data);
                                 Some(
                                     packed::CellDataEntryBuilder::default()
-                                        .output_data(data)
+                                        .output_data(data.pack())
                                         .output_data_hash(data_hash)
                                         .build(),
                                 )
diff --git a/store/src/store.rs b/store/src/store.rs
index 90657c5017..8e9b69a6d9 100644
--- a/store/src/store.rs
+++ b/store/src/store.rs
@@ -75,7 +75,7 @@ pub trait ChainStore: Send + Sync + Sized {
         };
         let ret = self.get(COLUMN_BLOCK_HEADER, hash.as_slice()).map(|slice| {
             let reader = packed::HeaderViewReader::from_slice_should_be_ok(slice.as_ref());
-            Into::<HeaderView>::into(reader)
+            Unpack::<HeaderView>::unpack(&reader)
         });
 
         if let Some(cache) = self.cache() {
@@ -98,7 +98,7 @@ pub trait ChainStore: Send + Sync + Sized {
         .take_while(|(key, _)| key.starts_with(prefix))
         .map(|(_key, value)| {
             let reader = packed::TransactionViewReader::from_slice_should_be_ok(value.as_ref());
-            Into::<TransactionView>::into(reader)
+            Unpack::<TransactionView>::unpack(&reader)
         })
         .collect()
     }
@@ -109,7 +109,7 @@ pub trait ChainStore: Send + Sync + Sized {
             .get(COLUMN_BLOCK_HEADER, hash.as_slice())
             .map(|slice| {
                 let reader = packed::HeaderViewReader::from_slice_should_be_ok(slice.as_ref());
-                Into::<HeaderView>::into(reader)
+                Unpack::<HeaderView>::unpack(&reader)
             })?;
 
         let body = self.get_block_body(hash);
@@ -119,7 +119,7 @@ pub trait ChainStore: Send + Sync + Sized {
             .map(|slice| {
                 let reader =
                     packed::UncleBlockVecViewReader::from_slice_should_be_ok(slice.as_ref());
-                Into::<UncleBlockVecView>::into(reader)
+                Unpack::<UncleBlockVecView>::unpack(&reader)
             })
             .expect("block uncles must be stored");
 
@@ -210,7 +210,7 @@ pub trait ChainStore: Send + Sync + Sized {
 
         let ret = self.get(COLUMN_BLOCK_UNCLE, hash.as_slice()).map(|slice| {
             let reader = packed::UncleBlockVecViewReader::from_slice_should_be_ok(slice.as_ref());
-            Into::<UncleBlockVecView>::into(reader)
+            Unpack::<UncleBlockVecView>::unpack(&reader)
         });
 
         if let Some(cache) = self.cache() {
@@ -250,8 +250,8 @@ pub trait ChainStore: Send + Sync + Sized {
                 let reader =
                     packed::BlockExtReader::from_compatible_slice_should_be_ok(slice.as_ref());
                 match reader.count_extra_fields() {
-                    0 => reader.into(),
-                    2 => packed::BlockExtV1Reader::from_slice_should_be_ok(slice.as_ref()).into(),
+                    0 => reader.unpack(),
+                    2 => packed::BlockExtV1Reader::from_slice_should_be_ok(slice.as_ref()).unpack(),
                     _ => {
                         panic!(
                             "BlockExt storage field count doesn't match, expect 7 or 5, actual {}",
@@ -264,7 +264,7 @@ pub trait ChainStore: Send + Sync + Sized {
 
     /// Get block header hash by block number
     fn get_block_hash(&self, number: BlockNumber) -> Option<packed::Byte32> {
-        let block_number: packed::Uint64 = number.into();
+        let block_number: packed::Uint64 = number.pack();
         self.get(COLUMN_INDEX, block_number.as_slice())
             .map(|raw| packed::Byte32Reader::from_slice_should_be_ok(raw.as_ref()).to_entity())
     }
@@ -272,7 +272,7 @@ pub trait ChainStore: Send + Sync + Sized {
     /// Get block number by block header hash
     fn get_block_number(&self, hash: &packed::Byte32) -> Option<BlockNumber> {
         self.get(COLUMN_INDEX, hash.as_slice())
-            .map(|raw| packed::Uint64Reader::from_slice_should_be_ok(raw.as_ref()).into())
+            .map(|raw| packed::Uint64Reader::from_slice_should_be_ok(raw.as_ref()).unpack())
     }
 
     /// TODO(doc): @quake
@@ -310,7 +310,7 @@ pub trait ChainStore: Send + Sync + Sized {
         self.get(COLUMN_TRANSACTION_INFO, hash.as_slice())
             .map(|slice| {
                 let reader = packed::TransactionInfoReader::from_slice_should_be_ok(slice.as_ref());
-                Into::<TransactionInfo>::into(reader)
+                Unpack::<TransactionInfo>::unpack(&reader)
             })
     }
 
@@ -334,7 +334,7 @@ pub trait ChainStore: Send + Sync + Sized {
         self.get(COLUMN_BLOCK_BODY, tx_info.key().as_slice())
             .map(|slice| {
                 let reader = packed::TransactionViewReader::from_slice_should_be_ok(slice.as_ref());
-                (reader.into(), tx_info)
+                (reader.unpack(), tx_info)
             })
     }
 
@@ -365,7 +365,7 @@ pub trait ChainStore: Send + Sync + Sized {
         let ret = self.get(COLUMN_CELL_DATA, &key).map(|slice| {
             if !slice.as_ref().is_empty() {
                 let reader = packed::CellDataEntryReader::from_slice_should_be_ok(slice.as_ref());
-                let data = reader.output_data().into();
+                let data = reader.output_data().unpack();
                 let data_hash = reader.output_data_hash().to_entity();
                 (data, data_hash)
             } else {
@@ -413,18 +413,18 @@ pub trait ChainStore: Send + Sync + Sized {
     /// Gets current epoch ext
     fn get_current_epoch_ext(&self) -> Option<EpochExt> {
         self.get(COLUMN_META, META_CURRENT_EPOCH_KEY)
-            .map(|slice| packed::EpochExtReader::from_slice_should_be_ok(slice.as_ref()).into())
+            .map(|slice| packed::EpochExtReader::from_slice_should_be_ok(slice.as_ref()).unpack())
     }
 
     /// Gets epoch ext by epoch index
     fn get_epoch_ext(&self, hash: &packed::Byte32) -> Option<EpochExt> {
         self.get(COLUMN_EPOCH, hash.as_slice())
-            .map(|slice| packed::EpochExtReader::from_slice_should_be_ok(slice.as_ref()).into())
+            .map(|slice| packed::EpochExtReader::from_slice_should_be_ok(slice.as_ref()).unpack())
     }
 
     /// Gets epoch index by epoch number
     fn get_epoch_index(&self, number: EpochNumber) -> Option<packed::Byte32> {
-        let epoch_number: packed::Uint64 = number.into();
+        let epoch_number: packed::Uint64 = number.pack();
         self.get(COLUMN_EPOCH, epoch_number.as_slice())
             .map(|raw| packed::Byte32Reader::from_slice_should_be_ok(raw.as_ref()).to_entity())
     }
@@ -450,7 +450,7 @@ pub trait ChainStore: Send + Sync + Sized {
     fn get_uncle_header(&self, hash: &packed::Byte32) -> Option<HeaderView> {
         self.get(COLUMN_UNCLES, hash.as_slice()).map(|slice| {
             let reader = packed::HeaderViewReader::from_slice_should_be_ok(slice.as_ref());
-            Into::<HeaderView>::into(reader)
+            Unpack::<HeaderView>::unpack(&reader)
         })
     }
 
@@ -471,7 +471,7 @@ pub trait ChainStore: Send + Sync + Sized {
             .build();
         self.get(COLUMN_BLOCK_BODY, key.as_slice()).map(|slice| {
             let reader = packed::TransactionViewReader::from_slice_should_be_ok(slice.as_ref());
-            Into::<TransactionView>::into(reader)
+            Unpack::<TransactionView>::unpack(&reader)
         })
     }
 
@@ -513,8 +513,7 @@ pub trait ChainStore: Send + Sync + Sized {
                 let reader = packed::TransactionViewReader::from_slice_should_be_ok(value.as_ref());
                 reader.data().to_entity()
             })
-            .collect::<Vec<_>>()
-            .into();
+            .pack();
 
         let uncles = self.get_block_uncles(hash)?;
         let proposals = self.get_block_proposal_txs_ids(hash)?;
@@ -551,7 +550,7 @@ pub trait ChainStore: Send + Sync + Sized {
 
     /// Gets a header digest.
     fn get_header_digest(&self, position_u64: u64) -> Option<packed::HeaderDigest> {
-        let position: packed::Uint64 = position_u64.into();
+        let position: packed::Uint64 = position_u64.pack();
         self.get(COLUMN_CHAIN_ROOT_MMR, position.as_slice())
             .map(|slice| {
                 let reader = packed::HeaderDigestReader::from_slice_should_be_ok(slice.as_ref());
@@ -580,12 +579,12 @@ fn build_cell_meta_from_reader(out_point: OutPoint, reader: packed::CellEntryRea
         out_point,
         cell_output: reader.output().to_entity(),
         transaction_info: Some(TransactionInfo {
-            block_number: reader.block_number().into(),
+            block_number: reader.block_number().unpack(),
             block_hash: reader.block_hash().to_entity(),
-            block_epoch: reader.block_epoch().into(),
-            index: reader.index().into(),
+            block_epoch: reader.block_epoch().unpack(),
+            index: reader.index().unpack(),
         }),
-        data_bytes: reader.data_size().into(),
+        data_bytes: reader.data_size().unpack(),
         mem_cell_data: None,
         mem_cell_data_hash: None,
     }
diff --git a/store/src/tests/db.rs b/store/src/tests/db.rs
index 5372d0f27e..39e1d24d61 100644
--- a/store/src/tests/db.rs
+++ b/store/src/tests/db.rs
@@ -31,7 +31,8 @@ fn save_and_get_block_with_transactions() {
         .transactions(
             (0..3)
                 .map(|_| packed::Transaction::new_builder().build())
-                .collect::<Vec<_>>(),
+                .collect::<Vec<_>>()
+                .pack(),
         )
         .build()
         .into_view();
@@ -97,7 +98,7 @@ fn freeze_blockv0() {
     let freezer = Freezer::open_in(&tmp_dir2).expect("tmp freezer");
     let store = ChainDB::new_with_freezer(db, freezer.clone(), Default::default());
 
-    let raw = packed::RawHeader::new_builder().number(1u64).build();
+    let raw = packed::RawHeader::new_builder().number(1u64.pack()).build();
     let block = packed::Block::new_builder()
         .header(packed::Header::new_builder().raw(raw).build())
         .build()
@@ -110,7 +111,7 @@ fn freeze_blockv0() {
     txn.insert_raw(
         COLUMN_BLOCK_HEADER,
         block_hash.as_slice(),
-        Into::<packed::HeaderView>::into(header).as_slice(),
+        header.pack().as_slice(),
     )
     .expect("insert header");
     txn.commit().expect("commit");
@@ -130,8 +131,8 @@ fn freeze_blockv1_with_extension() {
     let freezer = Freezer::open_in(&tmp_dir2).expect("tmp freezer");
     let store = ChainDB::new_with_freezer(db, freezer.clone(), Default::default());
 
-    let extension: packed::Bytes = [1u8; 96].as_slice().into();
-    let raw = packed::RawHeader::new_builder().number(1u64).build();
+    let extension: packed::Bytes = [1u8; 96].pack();
+    let raw = packed::RawHeader::new_builder().number(1u64.pack()).build();
     let block = packed::BlockV1::new_builder()
         .header(packed::Header::new_builder().raw(raw).build())
         .extension(extension)
@@ -146,7 +147,7 @@ fn freeze_blockv1_with_extension() {
     txn.insert_raw(
         COLUMN_BLOCK_HEADER,
         block_hash.as_slice(),
-        Into::<packed::HeaderView>::into(header).as_slice(),
+        header.pack().as_slice(),
     )
     .expect("insert header");
     txn.commit().expect("commit");
diff --git a/store/src/transaction.rs b/store/src/transaction.rs
index 51388d3091..62ba110b0f 100644
--- a/store/src/transaction.rs
+++ b/store/src/transaction.rs
@@ -173,10 +173,10 @@ impl StoreTransaction {
     /// TODO(doc): @quake
     pub fn insert_block(&self, block: &BlockView) -> Result<(), Error> {
         let hash = block.hash();
-        let header = Into::<packed::HeaderView>::into(block.header());
-        let uncles = Into::<packed::UncleBlockVecView>::into(block.uncles());
+        let header = block.header().pack();
+        let uncles = block.uncles().pack();
         let proposals = block.data().proposals();
-        let txs_len: packed::Uint32 = (block.transactions().len() as u32).into();
+        let txs_len: packed::Uint32 = (block.transactions().len() as u32).pack();
         self.insert_raw(COLUMN_BLOCK_HEADER, hash.as_slice(), header.as_slice())?;
         self.insert_raw(COLUMN_BLOCK_UNCLE, hash.as_slice(), uncles.as_slice())?;
         if let Some(extension) = block.extension() {
@@ -189,7 +189,7 @@ impl StoreTransaction {
         self.insert_raw(
             COLUMN_NUMBER_HASH,
             packed::NumberHash::new_builder()
-                .number(block.number())
+                .number(block.number().pack())
                 .block_hash(hash.clone())
                 .build()
                 .as_slice(),
@@ -203,9 +203,9 @@ impl StoreTransaction {
         for (index, tx) in block.transactions().into_iter().enumerate() {
             let key = packed::TransactionKey::new_builder()
                 .block_hash(hash.clone())
-                .index(index)
+                .index(index.pack())
                 .build();
-            let tx_data = Into::<packed::TransactionView>::into(tx);
+            let tx_data = tx.pack();
             self.insert_raw(COLUMN_BLOCK_BODY, key.as_slice(), tx_data.as_slice())?;
         }
         Ok(())
@@ -222,7 +222,7 @@ impl StoreTransaction {
         self.delete(
             COLUMN_NUMBER_HASH,
             packed::NumberHash::new_builder()
-                .number(block.number())
+                .number(block.number().pack())
                 .block_hash(hash.clone())
                 .build()
                 .as_slice(),
@@ -232,7 +232,7 @@ impl StoreTransaction {
         for index in 0..txs_len {
             let key = packed::TransactionKey::new_builder()
                 .block_hash(hash.clone())
-                .index(index)
+                .index(index.pack())
                 .build();
             self.delete(COLUMN_BLOCK_BODY, key.as_slice())?;
         }
@@ -245,7 +245,7 @@ impl StoreTransaction {
         block_hash: &packed::Byte32,
         ext: &BlockExt,
     ) -> Result<(), Error> {
-        let packed_ext: packed::BlockExtV1 = ext.into();
+        let packed_ext: packed::BlockExtV1 = ext.pack();
         self.insert_raw(
             COLUMN_BLOCK_EXT,
             block_hash.as_slice(),
@@ -260,7 +260,7 @@ impl StoreTransaction {
         for (index, tx_hash) in block.tx_hashes().iter().enumerate() {
             let key = packed::TransactionKey::new_builder()
                 .block_hash(block_hash.clone())
-                .index(index)
+                .index(index.pack())
                 .build();
             let info = packed::TransactionInfo::new_builder()
                 .key(key)
@@ -269,13 +269,13 @@ impl StoreTransaction {
                 .build();
             self.insert_raw(COLUMN_TRANSACTION_INFO, tx_hash.as_slice(), info.as_slice())?;
         }
-        let block_number: packed::Uint64 = block.number().into();
+        let block_number: packed::Uint64 = block.number().pack();
         self.insert_raw(COLUMN_INDEX, block_number.as_slice(), block_hash.as_slice())?;
         for uncle in block.uncles().into_iter() {
             self.insert_raw(
                 COLUMN_UNCLES,
                 uncle.hash().as_slice(),
-                Into::<packed::HeaderView>::into(uncle.header()).as_slice(),
+                uncle.header().pack().as_slice(),
             )?;
         }
         self.insert_raw(COLUMN_INDEX, block_hash.as_slice(), block_number.as_slice())
@@ -309,22 +309,14 @@ impl StoreTransaction {
 
     /// TODO(doc): @quake
     pub fn insert_epoch_ext(&self, hash: &packed::Byte32, epoch: &EpochExt) -> Result<(), Error> {
-        self.insert_raw(
-            COLUMN_EPOCH,
-            hash.as_slice(),
-            Into::<packed::EpochExt>::into(epoch).as_slice(),
-        )?;
-        let epoch_number: packed::Uint64 = epoch.number().into();
+        self.insert_raw(COLUMN_EPOCH, hash.as_slice(), epoch.pack().as_slice())?;
+        let epoch_number: packed::Uint64 = epoch.number().pack();
         self.insert_raw(COLUMN_EPOCH, epoch_number.as_slice(), hash.as_slice())
     }
 
     /// TODO(doc): @quake
     pub fn insert_current_epoch_ext(&self, epoch: &EpochExt) -> Result<(), Error> {
-        self.insert_raw(
-            COLUMN_META,
-            META_CURRENT_EPOCH_KEY,
-            Into::<packed::EpochExt>::into(epoch).as_slice(),
-        )
+        self.insert_raw(COLUMN_META, META_CURRENT_EPOCH_KEY, epoch.pack().as_slice())
     }
 
     /// TODO(doc): @quake
@@ -376,7 +368,7 @@ impl StoreTransaction {
         position_u64: u64,
         header_digest: &packed::HeaderDigest,
     ) -> Result<(), Error> {
-        let position: packed::Uint64 = position_u64.into();
+        let position: packed::Uint64 = position_u64.pack();
         self.insert_raw(
             COLUMN_CHAIN_ROOT_MMR,
             position.as_slice(),
@@ -386,7 +378,7 @@ impl StoreTransaction {
 
     /// Deletes a header digest.
     pub fn delete_header_digest(&self, position_u64: u64) -> Result<(), Error> {
-        let position: packed::Uint64 = position_u64.into();
+        let position: packed::Uint64 = position_u64.pack();
         self.delete(COLUMN_CHAIN_ROOT_MMR, position.as_slice())
     }
 
diff --git a/store/src/write_batch.rs b/store/src/write_batch.rs
index a2568505d2..65d74e2dc1 100644
--- a/store/src/write_batch.rs
+++ b/store/src/write_batch.rs
@@ -100,7 +100,7 @@ impl StoreWriteBatch {
         self.inner.delete(
             COLUMN_NUMBER_HASH,
             packed::NumberHash::new_builder()
-                .number(number)
+                .number(number.pack())
                 .block_hash(hash.clone())
                 .build()
                 .as_slice(),
@@ -109,7 +109,7 @@ impl StoreWriteBatch {
         let key_range = (0u32..txs_len).map(|i| {
             packed::TransactionKey::new_builder()
                 .block_hash(hash.clone())
-                .index(i)
+                .index(i.pack())
                 .build()
         });
 
diff --git a/sync/src/filter/get_block_filter_check_points_process.rs b/sync/src/filter/get_block_filter_check_points_process.rs
index e7b36d58be..a194525052 100644
--- a/sync/src/filter/get_block_filter_check_points_process.rs
+++ b/sync/src/filter/get_block_filter_check_points_process.rs
@@ -33,7 +33,7 @@ impl<'a> GetBlockFilterCheckPointsProcess<'a> {
 
     pub fn execute(self) -> Status {
         let active_chain = self.filter.shared.active_chain();
-        let start_number: BlockNumber = self.message.to_entity().start_number().into();
+        let start_number: BlockNumber = self.message.to_entity().start_number().unpack();
         let latest: BlockNumber = active_chain.get_latest_built_filter_block_number();
 
         let mut block_filter_hashes = Vec::new();
@@ -52,8 +52,8 @@ impl<'a> GetBlockFilterCheckPointsProcess<'a> {
                 }
             }
             let content = packed::BlockFilterCheckPoints::new_builder()
-                .start_number(start_number)
-                .block_filter_hashes(block_filter_hashes)
+                .start_number(start_number.pack())
+                .block_filter_hashes(block_filter_hashes.pack())
                 .build();
 
             let message = packed::BlockFilterMessage::new_builder()
diff --git a/sync/src/filter/get_block_filter_hashes_process.rs b/sync/src/filter/get_block_filter_hashes_process.rs
index 3576ca0119..c1a3f5a6e0 100644
--- a/sync/src/filter/get_block_filter_hashes_process.rs
+++ b/sync/src/filter/get_block_filter_hashes_process.rs
@@ -31,7 +31,7 @@ impl<'a> GetBlockFilterHashesProcess<'a> {
 
     pub fn execute(self) -> Status {
         let active_chain = self.filter.shared.active_chain();
-        let start_number: BlockNumber = self.message.to_entity().start_number().into();
+        let start_number: BlockNumber = self.message.to_entity().start_number().unpack();
         let latest: BlockNumber = active_chain.get_latest_built_filter_block_number();
 
         let mut block_filter_hashes = Vec::new();
@@ -60,9 +60,9 @@ impl<'a> GetBlockFilterHashesProcess<'a> {
                 }
             }
             let content = packed::BlockFilterHashes::new_builder()
-                .start_number(start_number)
+                .start_number(start_number.pack())
                 .parent_block_filter_hash(parent_block_filter_hash)
-                .block_filter_hashes(block_filter_hashes)
+                .block_filter_hashes(block_filter_hashes.pack())
                 .build();
 
             let message = packed::BlockFilterMessage::new_builder()
diff --git a/sync/src/filter/get_block_filters_process.rs b/sync/src/filter/get_block_filters_process.rs
index e5e6f38d31..22e527f0e5 100644
--- a/sync/src/filter/get_block_filters_process.rs
+++ b/sync/src/filter/get_block_filters_process.rs
@@ -32,7 +32,7 @@ impl<'a> GetBlockFiltersProcess<'a> {
 
     pub fn execute(self) -> Status {
         let active_chain = self.filter.shared.active_chain();
-        let start_number: BlockNumber = self.message.to_entity().start_number().into();
+        let start_number: BlockNumber = self.message.to_entity().start_number().unpack();
         let latest: BlockNumber = active_chain.get_latest_built_filter_block_number();
 
         if latest >= start_number {
@@ -51,9 +51,9 @@ impl<'a> GetBlockFiltersProcess<'a> {
                 }
             }
             let content = packed::BlockFilters::new_builder()
-                .start_number(start_number)
-                .block_hashes(block_hashes)
-                .filters(filters)
+                .start_number(start_number.pack())
+                .block_hashes(block_hashes.pack())
+                .filters(filters.pack())
                 .build();
 
             let message = packed::BlockFilterMessage::new_builder()
diff --git a/sync/src/net_time_checker.rs b/sync/src/net_time_checker.rs
index aa384f9151..259a2eae57 100644
--- a/sync/src/net_time_checker.rs
+++ b/sync/src/net_time_checker.rs
@@ -118,7 +118,7 @@ impl CKBProtocolHandler for NetTimeProtocol {
         // send local time to inbound peers
         if let Some(true) = nc.get_peer(peer_index).map(|peer| peer.is_inbound()) {
             let now = ckb_systemtime::unix_time_as_millis();
-            let time = packed::Time::new_builder().timestamp(now).build();
+            let time = packed::Time::new_builder().timestamp(now.pack()).build();
             let _status = send_message_to(nc.as_ref(), peer_index, &time);
         }
     }
@@ -137,7 +137,7 @@ impl CKBProtocolHandler for NetTimeProtocol {
         }
 
         let timestamp: u64 = match packed::TimeReader::from_slice(&data)
-            .map(|time| time.timestamp().into())
+            .map(|time| time.timestamp().unpack())
             .ok()
         {
             Some(timestamp) => timestamp,
diff --git a/sync/src/relayer/block_transactions_process.rs b/sync/src/relayer/block_transactions_process.rs
index c2c10077a4..fa5522e349 100644
--- a/sync/src/relayer/block_transactions_process.rs
+++ b/sync/src/relayer/block_transactions_process.rs
@@ -162,8 +162,8 @@ impl<'a> BlockTransactionsProcess<'a> {
 
                 let content = packed::GetBlockTransactions::new_builder()
                     .block_hash(block_hash.clone())
-                    .indexes(missing_transactions.as_slice())
-                    .uncle_indexes(missing_uncles.as_slice())
+                    .indexes(missing_transactions.pack())
+                    .uncle_indexes(missing_uncles.pack())
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/sync/src/relayer/compact_block_process.rs b/sync/src/relayer/compact_block_process.rs
index 9ee0d40918..b46dcca1ef 100644
--- a/sync/src/relayer/compact_block_process.rs
+++ b/sync/src/relayer/compact_block_process.rs
@@ -112,7 +112,7 @@ impl<'a> CompactBlockProcess<'a> {
                 // use epoch as the judgment condition because we accept
                 // all block in current epoch as uncle block
                 pending_compact_blocks.retain(|_, (v, _, _)| {
-                    Into::<EpochNumberWithFraction>::into(v.header().as_reader().raw().epoch())
+                    Unpack::<EpochNumberWithFraction>::unpack(&v.header().as_reader().raw().epoch())
                         .number()
                         >= block.epoch().number()
                 });
@@ -359,8 +359,8 @@ fn missing_or_collided_post_process(
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block_hash)
-        .indexes(missing_transactions.as_slice())
-        .uncle_indexes(missing_uncles.as_slice())
+        .indexes(missing_transactions.pack())
+        .uncle_indexes(missing_uncles.pack())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let sending = send_message_to(nc.as_ref(), peer, &message);
diff --git a/sync/src/relayer/compact_block_verifier.rs b/sync/src/relayer/compact_block_verifier.rs
index 61ce34772e..549735c1cb 100644
--- a/sync/src/relayer/compact_block_verifier.rs
+++ b/sync/src/relayer/compact_block_verifier.rs
@@ -1,5 +1,5 @@
 use crate::{attempt, Status, StatusCode};
-use ckb_types::packed;
+use ckb_types::{packed, prelude::*};
 use std::collections::HashSet;
 
 // we assume that all the short_ids and prefilled transactions
@@ -28,7 +28,7 @@ impl PrefilledVerifier {
             return StatusCode::CompactBlockHasNotPrefilledCellbase.into();
         } else {
             // Check first prefilled index is zero
-            let index: usize = prefilled_transactions.get(0).unwrap().index().into();
+            let index: usize = prefilled_transactions.get(0).unwrap().index().unpack();
             if index != 0 {
                 return StatusCode::CompactBlockHasNotPrefilledCellbase.into();
             }
@@ -38,7 +38,7 @@ impl PrefilledVerifier {
                 .get(prefilled_transactions.len() - 1)
                 .unwrap()
                 .index()
-                .into();
+                .unpack();
             if index >= txs_len {
                 return StatusCode::CompactBlockHasOutOfIndexPrefilledTransactions.into();
             }
@@ -46,8 +46,8 @@ impl PrefilledVerifier {
 
         // Check indices order of prefilled transactions
         for i in 0..(prefilled_transactions.len() - 1) {
-            let idx0: usize = prefilled_transactions.get(i).unwrap().index().into();
-            let idx1: usize = prefilled_transactions.get(i + 1).unwrap().index().into();
+            let idx0: usize = prefilled_transactions.get(i).unwrap().index().unpack();
+            let idx1: usize = prefilled_transactions.get(i + 1).unwrap().index().unpack();
             if idx0 >= idx1 {
                 return StatusCode::CompactBlockHasOutOfOrderPrefilledTransactions.into();
             }
diff --git a/sync/src/relayer/get_block_proposal_process.rs b/sync/src/relayer/get_block_proposal_process.rs
index 59fd24189c..b7321ba1c3 100644
--- a/sync/src/relayer/get_block_proposal_process.rs
+++ b/sync/src/relayer/get_block_proposal_process.rs
@@ -97,7 +97,7 @@ impl<'a> GetBlockProposalProcess<'a> {
 
     fn send_block_proposals(&self, txs: Vec<packed::Transaction>) -> Status {
         let content = packed::BlockProposal::new_builder()
-            .transactions(txs)
+            .transactions(txs.into_iter().pack())
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
         send_message_to(self.nc.as_ref(), self.peer, &message)
diff --git a/sync/src/relayer/get_block_transactions_process.rs b/sync/src/relayer/get_block_transactions_process.rs
index b6c249c2aa..bfff3ebc11 100644
--- a/sync/src/relayer/get_block_transactions_process.rs
+++ b/sync/src/relayer/get_block_transactions_process.rs
@@ -4,7 +4,6 @@ use crate::{attempt, Status, StatusCode};
 use ckb_logger::debug_target;
 use ckb_network::{CKBProtocolContext, PeerIndex};
 use ckb_store::ChainStore;
-use ckb_types::packed::{Transaction, UncleBlock};
 use ckb_types::{packed, prelude::*};
 use std::sync::Arc;
 
@@ -66,7 +65,7 @@ impl<'a> GetBlockTransactionsProcess<'a> {
                 .filter_map(|i| {
                     block
                         .transactions()
-                        .get(Into::<u32>::into(i) as usize)
+                        .get(Unpack::<u32>::unpack(&i) as usize)
                         .cloned()
                 })
                 .collect::<Vec<_>>();
@@ -75,23 +74,13 @@ impl<'a> GetBlockTransactionsProcess<'a> {
                 .message
                 .uncle_indexes()
                 .iter()
-                .filter_map(|i| block.uncles().get(Into::<u32>::into(i) as usize))
+                .filter_map(|i| block.uncles().get(Unpack::<u32>::unpack(&i) as usize))
                 .collect::<Vec<_>>();
 
             let content = packed::BlockTransactions::new_builder()
                 .block_hash(block_hash)
-                .transactions(
-                    transactions
-                        .into_iter()
-                        .map(|tx| tx.data())
-                        .collect::<Vec<Transaction>>(),
-                )
-                .uncles(
-                    uncles
-                        .into_iter()
-                        .map(|uncle| uncle.data())
-                        .collect::<Vec<UncleBlock>>(),
-                )
+                .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
+                .uncles(uncles.into_iter().map(|uncle| uncle.data()).pack())
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/sync/src/relayer/get_transactions_process.rs b/sync/src/relayer/get_transactions_process.rs
index 766ff2af4d..60e8067455 100644
--- a/sync/src/relayer/get_transactions_process.rs
+++ b/sync/src/relayer/get_transactions_process.rs
@@ -76,7 +76,7 @@ impl<'a> GetTransactionsProcess<'a> {
                 .into_iter()
                 .map(|(_, (tx, cycles))| {
                     packed::RelayTransaction::new_builder()
-                        .cycles(cycles)
+                        .cycles(cycles.pack())
                         .transaction(tx.data())
                         .build()
                 })
diff --git a/sync/src/relayer/mod.rs b/sync/src/relayer/mod.rs
index 366bd8e292..0a143e9770 100644
--- a/sync/src/relayer/mod.rs
+++ b/sync/src/relayer/mod.rs
@@ -38,7 +38,6 @@ use ckb_shared::block_status::BlockStatus;
 use ckb_shared::Shared;
 use ckb_systemtime::unix_time_as_millis;
 use ckb_tx_pool::service::TxVerificationResult;
-use ckb_types::packed::Transaction;
 use ckb_types::BlockNumberAndHash;
 use ckb_types::{
     core::{self, BlockView},
@@ -272,7 +271,7 @@ impl Relayer {
         if !to_ask_proposals.is_empty() {
             let content = packed::GetBlockProposal::new_builder()
                 .block_hash(block_hash_and_number.hash)
-                .proposals(to_ask_proposals.clone())
+                .proposals(to_ask_proposals.clone().pack())
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
             if !send_message_to(nc, peer, &message).is_ok() {
@@ -416,7 +415,7 @@ impl Relayer {
             .prefilled_transactions()
             .into_iter()
             .for_each(|pt| {
-                let index: usize = pt.index().into();
+                let index: usize = pt.index().unpack();
                 let gap = index - block_transactions.len();
                 if gap > 0 {
                     short_ids_iter
@@ -496,12 +495,8 @@ impl Relayer {
             let block = if let Some(extension) = compact_block.extension() {
                 packed::BlockV1::new_builder()
                     .header(compact_block.header())
-                    .uncles(uncles)
-                    .transactions(
-                        txs.into_iter()
-                            .map(|tx| tx.data())
-                            .collect::<Vec<Transaction>>(),
-                    )
+                    .uncles(uncles.pack())
+                    .transactions(txs.into_iter().map(|tx| tx.data()).pack())
                     .proposals(compact_block.proposals())
                     .extension(extension)
                     .build()
@@ -509,12 +504,8 @@ impl Relayer {
             } else {
                 packed::Block::new_builder()
                     .header(compact_block.header())
-                    .uncles(uncles)
-                    .transactions(
-                        txs.into_iter()
-                            .map(|tx| tx.data())
-                            .collect::<Vec<Transaction>>(),
-                    )
+                    .uncles(uncles.pack())
+                    .transactions(txs.into_iter().map(|tx| tx.data()).pack())
                     .proposals(compact_block.proposals())
                     .build()
             }
@@ -602,7 +593,7 @@ impl Relayer {
         let send_block_proposals =
             |nc: &dyn CKBProtocolContext, peer_index: PeerIndex, txs: Vec<packed::Transaction>| {
                 let content = packed::BlockProposal::new_builder()
-                    .transactions(txs)
+                    .transactions(txs.into_iter().pack())
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
                 let status = send_message_to(nc, peer_index, &message);
@@ -648,7 +639,7 @@ impl Relayer {
                 );
                 tx_hashes.truncate(MAX_RELAY_TXS_NUM_PER_BATCH);
                 let content = packed::GetRelayTransactions::new_builder()
-                    .tx_hashes(tx_hashes)
+                    .tx_hashes(tx_hashes.pack())
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
                 let status = send_message_to(nc, peer, &message);
@@ -730,7 +721,7 @@ impl Relayer {
         }
         for (peer, hashes) in selected {
             let content = packed::RelayTransactionHashes::new_builder()
-                .tx_hashes(hashes)
+                .tx_hashes(hashes.pack())
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
 
@@ -799,7 +790,7 @@ fn build_and_broadcast_compact_block(
         let tip_header = packed::VerifiableHeader::new_builder()
             .header(block.header().data())
             .uncles_hash(block.calc_uncles_hash())
-            .extension(block.extension())
+            .extension(Pack::pack(&block.extension()))
             .parent_chain_root(parent_chain_root)
             .build();
         let light_client_message = {
diff --git a/sync/src/relayer/tests/block_proposal_process.rs b/sync/src/relayer/tests/block_proposal_process.rs
index fb56fa01ce..e88ec876ad 100644
--- a/sync/src/relayer/tests/block_proposal_process.rs
+++ b/sync/src/relayer/tests/block_proposal_process.rs
@@ -1,7 +1,7 @@
 use crate::relayer::block_proposal_process::BlockProposalProcess;
 use crate::relayer::tests::helper::{build_chain, new_transaction};
 use crate::Status;
-use ckb_types::packed::{self, ProposalShortId, Transaction};
+use ckb_types::packed::{self, ProposalShortId};
 use ckb_types::prelude::*;
 
 #[test]
@@ -16,12 +16,7 @@ fn test_no_unknown() {
         relayer.shared.state().mark_as_known_tx(transaction.hash());
     }
     let content = packed::BlockProposal::new_builder()
-        .transactions(
-            transactions
-                .into_iter()
-                .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>(),
-        )
+        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
@@ -36,12 +31,7 @@ fn test_no_asked() {
     let transactions = vec![transaction.clone()];
 
     let content = packed::BlockProposal::new_builder()
-        .transactions(
-            transactions
-                .into_iter()
-                .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>(),
-        )
+        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
@@ -70,12 +60,7 @@ fn test_ok() {
     }
 
     let content = packed::BlockProposal::new_builder()
-        .transactions(
-            transactions
-                .into_iter()
-                .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>(),
-        )
+        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
@@ -104,12 +89,7 @@ fn test_clear_expired_inflight_proposals() {
     }
 
     let content = packed::BlockProposal::new_builder()
-        .transactions(
-            transactions
-                .into_iter()
-                .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>(),
-        )
+        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
diff --git a/sync/src/relayer/tests/block_transactions_process.rs b/sync/src/relayer/tests/block_transactions_process.rs
index 247baae90a..8b106b7d3f 100644
--- a/sync/src/relayer/tests/block_transactions_process.rs
+++ b/sync/src/relayer/tests/block_transactions_process.rs
@@ -26,24 +26,22 @@ fn test_accept_block() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap())
+                .capacity(Capacity::bytes(1).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let tx3 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap())
+                .capacity(Capacity::bytes(2).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
     let uncle = BlockBuilder::default()
-        .proposals(Into::<packed::ProposalShortIdVec>::into(vec![
-            tx3.proposal_short_id()
-        ]))
+        .proposals(vec![tx3.proposal_short_id()].pack())
         .build();
 
     let block = BlockBuilder::default()
@@ -72,8 +70,8 @@ fn test_accept_block() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()])
-        .uncles(vec![uncle.as_uncle().data()])
+        .transactions(vec![tx2.data()].pack())
+        .uncles(vec![uncle.as_uncle().data()].pack())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -106,10 +104,10 @@ fn test_unknown_request() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap())
+                .capacity(Capacity::bytes(1).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let block = BlockBuilder::default()
@@ -135,7 +133,7 @@ fn test_unknown_request() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()])
+        .transactions(vec![tx2.data()].pack())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -159,14 +157,14 @@ fn test_invalid_transaction_root() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap())
+                .capacity(Capacity::bytes(1).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let prefilled = IndexTransaction::new_builder()
-        .index(0u32)
+        .index(0u32.pack())
         .transaction(tx1.data())
         .build();
 
@@ -180,8 +178,8 @@ fn test_invalid_transaction_root() {
 
     let compact_block = packed::CompactBlock::new_builder()
         .header(header_with_invalid_tx_root)
-        .short_ids(vec![tx2.proposal_short_id()])
-        .prefilled_transactions(vec![prefilled])
+        .short_ids(vec![tx2.proposal_short_id()].pack())
+        .prefilled_transactions(vec![prefilled].pack())
         .build();
 
     let block_hash = compact_block.header().calc_header_hash();
@@ -200,7 +198,7 @@ fn test_invalid_transaction_root() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block_hash)
-        .transactions(vec![tx2.data()])
+        .transactions(vec![tx2.data()].pack())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -236,28 +234,28 @@ fn test_collision_and_send_missing_indexes() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1000).unwrap())
+                .capacity(Capacity::bytes(1000).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
     let tx3 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(last_cellbase.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap())
+                .capacity(Capacity::bytes(2).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let fake_hash = tx3
         .hash()
         .as_builder()
-        .nth31(0u8)
-        .nth30(0u8)
-        .nth29(0u8)
-        .nth28(0u8)
+        .nth31(0u8.into())
+        .nth30(0u8.into())
+        .nth29(0u8.into())
+        .nth28(0u8.into())
         .build();
     // Fake tx with the same ProposalShortId but different hash with tx3
     let fake_tx = tx3.clone().fake_hash(fake_hash);
@@ -296,7 +294,7 @@ fn test_collision_and_send_missing_indexes() {
 
     let block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()])
+        .transactions(vec![tx2.data()].pack())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -315,7 +313,7 @@ fn test_collision_and_send_missing_indexes() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1u32, 2u32])
+        .indexes([1u32, 2u32].pack())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let data = message.as_bytes();
@@ -339,7 +337,7 @@ fn test_collision_and_send_missing_indexes() {
     // resend BlockTransactions with all the transactions without prefilled
     let new_block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data(), tx3.data()])
+        .transactions(vec![tx2.data(), tx3.data()].pack())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -372,18 +370,18 @@ fn test_missing() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap())
+                .capacity(Capacity::bytes(1).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
     let tx3 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap())
+                .capacity(Capacity::bytes(2).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let block = BlockBuilder::default()
@@ -410,7 +408,7 @@ fn test_missing() {
 
     let block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()])
+        .transactions(vec![tx2.data()].pack())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -429,7 +427,7 @@ fn test_missing() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1, 2u32])
+        .indexes([1, 2u32].pack())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/sync/src/relayer/tests/block_transactions_verifier.rs b/sync/src/relayer/tests/block_transactions_verifier.rs
index 6934c1f5af..16d49ac962 100644
--- a/sync/src/relayer/tests/block_transactions_verifier.rs
+++ b/sync/src/relayer/tests/block_transactions_verifier.rs
@@ -1,25 +1,21 @@
 use super::helper::new_index_transaction;
 use crate::relayer::block_transactions_verifier::BlockTransactionsVerifier;
 use crate::{Status, StatusCode};
-use ckb_types::packed::{self, CompactBlock, CompactBlockBuilder};
+use ckb_types::packed::{CompactBlock, CompactBlockBuilder};
 use ckb_types::prelude::*;
 
 // block_short_ids: vec![None, Some(1), None, Some(3), Some(4), None]
 fn build_compact_block() -> CompactBlock {
-    let prefilled_iter = vec![0, 2, 5]
-        .into_iter()
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
+    let prefilled_iter = vec![0, 2, 5].into_iter().map(new_index_transaction);
 
     let short_ids = vec![1, 3, 4]
         .into_iter()
         .map(new_index_transaction)
-        .map(|tx| tx.transaction().proposal_short_id())
-        .collect::<Vec<packed::ProposalShortId>>();
+        .map(|tx| tx.transaction().proposal_short_id());
 
     CompactBlockBuilder::default()
-        .short_ids(short_ids)
-        .prefilled_transactions(prefilled_iter)
+        .short_ids(short_ids.pack())
+        .prefilled_transactions(prefilled_iter.pack())
         .build()
 }
 
diff --git a/sync/src/relayer/tests/compact_block.rs b/sync/src/relayer/tests/compact_block.rs
index 72b6169a81..12845293f8 100644
--- a/sync/src/relayer/tests/compact_block.rs
+++ b/sync/src/relayer/tests/compact_block.rs
@@ -13,18 +13,18 @@ fn test_block_short_ids() {
     ];
     let prefilled_transactions = vec![
         IndexTransactionBuilder::default()
-            .index(0u32)
+            .index(0u32.pack())
             .transaction(TransactionBuilder::default().build().data())
             .build(),
         IndexTransactionBuilder::default()
-            .index(2u32)
+            .index(2u32.pack())
             .transaction(TransactionBuilder::default().build().data())
             .build(),
     ];
 
     let compact_block = compact_block_builder
-        .short_ids(short_ids)
-        .prefilled_transactions(prefilled_transactions)
+        .short_ids(short_ids.into_iter().pack())
+        .prefilled_transactions(prefilled_transactions.into_iter().pack())
         .build();
 
     assert_eq!(
diff --git a/sync/src/relayer/tests/compact_block_process.rs b/sync/src/relayer/tests/compact_block_process.rs
index 1948a47e81..3473b8e405 100644
--- a/sync/src/relayer/tests/compact_block_process.rs
+++ b/sync/src/relayer/tests/compact_block_process.rs
@@ -113,9 +113,9 @@ fn test_unknow_parent() {
     let block = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(5)
-                .epoch(EpochNumberWithFraction::new(1, 5, 1000))
-                .timestamp(unix_time_as_millis())
+                .number(5.pack())
+                .epoch(EpochNumberWithFraction::new(1, 5, 1000).pack())
+                .timestamp(unix_time_as_millis().pack())
                 .build(),
         )
         .transaction(TransactionBuilder::default().build())
@@ -145,7 +145,7 @@ fn test_unknow_parent() {
     let locator_hash = active_chain.get_locator((&header).into());
 
     let content = packed::GetHeaders::new_builder()
-        .block_locator_hashes(locator_hash)
+        .block_locator_hashes(locator_hash.pack())
         .hash_stop(packed::Byte32::zero())
         .build();
     let message = packed::SyncMessage::new_builder().set(content).build();
@@ -227,7 +227,7 @@ fn test_header_invalid() {
 
     // Better block but block number is invalid
     let header = new_header_builder(relayer.shared.shared(), &parent)
-        .number(4)
+        .number(4.pack())
         .build();
 
     let block = BlockBuilder::default()
@@ -285,10 +285,10 @@ fn test_send_missing_indexes() {
             TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(Capacity::bytes(1).unwrap())
+                        .capacity(Capacity::bytes(1).unwrap().pack())
                         .build(),
                 )
-                .output_data(Bytes::new())
+                .output_data(Bytes::new().pack())
                 .build(),
         )
         .uncle(uncle.as_uncle())
@@ -321,8 +321,8 @@ fn test_send_missing_indexes() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1u32])
-        .uncle_indexes([0u32])
+        .indexes([1u32].pack())
+        .uncle_indexes([0u32].pack())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let data = message.as_bytes();
@@ -338,7 +338,7 @@ fn test_send_missing_indexes() {
 
     let content = packed::GetBlockProposal::new_builder()
         .block_hash(block.header().hash())
-        .proposals(vec![proposal_id])
+        .proposals(vec![proposal_id].into_iter().pack())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let data = message.as_bytes();
@@ -368,12 +368,12 @@ fn test_accept_block() {
     );
 
     let mock_block_1 = BlockBuilder::default()
-        .number(4)
-        .epoch(EpochNumberWithFraction::new(1, 4, 1000))
+        .number(4.pack())
+        .epoch(EpochNumberWithFraction::new(1, 4, 1000).pack())
         .build();
     let mock_compact_block_1 = CompactBlock::build_from_block(&mock_block_1, &Default::default());
 
-    let mock_block_2 = block.as_advanced_builder().number(7).build();
+    let mock_block_2 = block.as_advanced_builder().number(7.pack()).build();
     let mock_compact_block_2 = CompactBlock::build_from_block(&mock_block_2, &Default::default());
     {
         let mut pending_compact_blocks = relayer.shared.state().pending_compact_blocks();
@@ -522,20 +522,20 @@ fn test_collision() {
     let missing_tx = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1000).unwrap())
+                .capacity(Capacity::bytes(1000).unwrap().pack())
                 .build(),
         )
         .input(CellInput::new(OutPoint::new(last_cellbase.hash(), 0), 0))
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let fake_hash = missing_tx
         .hash()
         .as_builder()
-        .nth31(0u8)
-        .nth30(0u8)
-        .nth29(0u8)
-        .nth28(0u8)
+        .nth31(0u8.into())
+        .nth30(0u8.into())
+        .nth29(0u8.into())
+        .nth28(0u8.into())
         .build();
     // Fake tx with the same ProposalShortId but different hash with missing_tx
     let fake_tx = missing_tx.clone().fake_hash(fake_hash);
@@ -589,7 +589,7 @@ fn test_collision() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1u32])
+        .indexes([1u32].pack())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let data = message.as_bytes();
diff --git a/sync/src/relayer/tests/compact_block_verifier.rs b/sync/src/relayer/tests/compact_block_verifier.rs
index e85da0c024..e0d7f3125d 100644
--- a/sync/src/relayer/tests/compact_block_verifier.rs
+++ b/sync/src/relayer/tests/compact_block_verifier.rs
@@ -1,17 +1,14 @@
 use super::helper::new_index_transaction;
 use crate::relayer::compact_block_verifier::{PrefilledVerifier, ShortIdsVerifier};
 use crate::{Status, StatusCode};
-use ckb_types::packed::{self, CompactBlockBuilder, ProposalShortId};
+use ckb_types::packed::{CompactBlockBuilder, ProposalShortId};
 use ckb_types::prelude::*;
 
 #[test]
 fn test_unordered_prefilled() {
-    let prefilled = vec![0, 1, 2, 4, 3]
-        .into_iter()
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
+    let prefilled = vec![0, 1, 2, 4, 3].into_iter().map(new_index_transaction);
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled)
+        .prefilled_transactions(prefilled.pack())
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -21,23 +18,18 @@ fn test_unordered_prefilled() {
 
 #[test]
 fn test_ordered_prefilled() {
-    let prefilled = (0..5)
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
+    let prefilled = (0..5).map(new_index_transaction);
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled)
+        .prefilled_transactions(prefilled.pack())
         .build();
     assert_eq!(PrefilledVerifier::verify(&block), Status::ok());
 }
 
 #[test]
 fn test_overflow_prefilled() {
-    let prefilled = vec![0, 1, 2, 5]
-        .into_iter()
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
+    let prefilled = vec![0, 1, 2, 5].into_iter().map(new_index_transaction);
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled)
+        .prefilled_transactions(prefilled.pack())
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -53,11 +45,9 @@ fn test_cellbase_not_prefilled() {
         StatusCode::CompactBlockHasNotPrefilledCellbase.into(),
     );
 
-    let prefilled = (1..5)
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
+    let prefilled = (1..5).map(new_index_transaction);
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled)
+        .prefilled_transactions(prefilled.pack())
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -72,7 +62,9 @@ fn test_duplicated_short_ids() {
         .collect();
     short_ids.push(short_ids[0].clone());
 
-    let block = CompactBlockBuilder::default().short_ids(short_ids).build();
+    let block = CompactBlockBuilder::default()
+        .short_ids(short_ids.into_iter().pack())
+        .build();
     assert_eq!(
         ShortIdsVerifier::verify(&block),
         StatusCode::CompactBlockHasDuplicatedShortIds.into(),
@@ -81,16 +73,12 @@ fn test_duplicated_short_ids() {
 
 #[test]
 fn test_intersected_short_ids() {
-    let prefilled = (0..=5)
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
-    let short_ids = (5..9)
-        .map(|i| new_index_transaction(i).transaction().proposal_short_id())
-        .collect::<Vec<packed::ProposalShortId>>();
+    let prefilled = (0..=5).map(new_index_transaction);
+    let short_ids = (5..9).map(|i| new_index_transaction(i).transaction().proposal_short_id());
 
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled)
-        .short_ids(short_ids)
+        .prefilled_transactions(prefilled.pack())
+        .short_ids(short_ids.pack())
         .build();
     assert_eq!(
         ShortIdsVerifier::verify(&block),
@@ -100,17 +88,13 @@ fn test_intersected_short_ids() {
 
 #[test]
 fn test_normal() {
-    let prefilled = vec![1, 2, 5]
-        .into_iter()
-        .map(new_index_transaction)
-        .collect::<Vec<packed::IndexTransaction>>();
+    let prefilled = vec![1, 2, 5].into_iter().map(new_index_transaction);
     let short_ids = vec![0, 3, 4]
         .into_iter()
-        .map(|i| new_index_transaction(i).transaction().proposal_short_id())
-        .collect::<Vec<packed::ProposalShortId>>();
+        .map(|i| new_index_transaction(i).transaction().proposal_short_id());
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled)
-        .short_ids(short_ids)
+        .prefilled_transactions(prefilled.pack())
+        .short_ids(short_ids.pack())
         .build();
     assert_eq!(ShortIdsVerifier::verify(&block), Status::ok());
 }
diff --git a/sync/src/relayer/tests/get_block_proposal_process.rs b/sync/src/relayer/tests/get_block_proposal_process.rs
index f38308dc06..568ba83dc7 100644
--- a/sync/src/relayer/tests/get_block_proposal_process.rs
+++ b/sync/src/relayer/tests/get_block_proposal_process.rs
@@ -17,7 +17,7 @@ fn test_duplicate() {
 
     let content = packed::GetBlockProposal::new_builder()
         .block_hash(hash)
-        .proposals(vec![id.clone(), id])
+        .proposals(vec![id.clone(), id].into_iter().pack())
         .build();
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
     let nc = Arc::new(mock_protocol_context);
diff --git a/sync/src/relayer/tests/get_transactions_process.rs b/sync/src/relayer/tests/get_transactions_process.rs
index 6839daf7bb..7f38edf5ad 100644
--- a/sync/src/relayer/tests/get_transactions_process.rs
+++ b/sync/src/relayer/tests/get_transactions_process.rs
@@ -13,7 +13,7 @@ fn test_duplicate() {
     let tx = new_transaction(&relayer, 1, &always_success_out_point);
     let tx_hash = tx.hash();
     let content = packed::GetRelayTransactions::new_builder()
-        .tx_hashes(vec![tx_hash.clone(), tx_hash])
+        .tx_hashes(vec![tx_hash.clone(), tx_hash].pack())
         .build();
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
     let nc = Arc::new(mock_protocol_context);
diff --git a/sync/src/relayer/tests/helper.rs b/sync/src/relayer/tests/helper.rs
index 72d85709cd..a11ceb1fe8 100644
--- a/sync/src/relayer/tests/helper.rs
+++ b/sync/src/relayer/tests/helper.rs
@@ -38,14 +38,14 @@ pub(crate) fn new_index_transaction(index: usize) -> IndexTransaction {
     let transaction = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(index).unwrap())
+                .capacity(Capacity::bytes(index).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     IndexTransactionBuilder::default()
-        .index(index)
+        .index(index.pack())
         .transaction(transaction.data())
         .build()
 }
@@ -60,10 +60,10 @@ pub(crate) fn new_header_builder(shared: &Shared, parent: &HeaderView) -> Header
         .epoch();
     HeaderBuilder::default()
         .parent_hash(parent_hash)
-        .number(parent.number() + 1)
-        .timestamp(parent.timestamp() + 1)
-        .epoch(epoch.number_with_fraction(parent.number() + 1))
-        .compact_target(epoch.compact_target())
+        .number((parent.number() + 1).pack())
+        .timestamp((parent.timestamp() + 1).pack())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+        .compact_target(epoch.compact_target().pack())
 }
 
 pub(crate) fn new_transaction(
@@ -89,10 +89,10 @@ pub(crate) fn new_transaction(
         .input(CellInput::new(previous_output, 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(500 + index).unwrap() ) // use capacity to identify transactions
+                .capacity(Capacity::bytes(500 + index).unwrap().pack()) // use capacity to identify transactions
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .cell_dep(
             CellDep::new_builder()
                 .out_point(always_success_out_point.to_owned())
@@ -138,7 +138,7 @@ pub(crate) fn build_chain(tip: BlockNumber) -> (Relayer, OutPoint) {
     let always_success_tx = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::null(), 0))
         .output(always_success_cell.clone())
-        .output_data(always_success_cell_data)
+        .output_data(always_success_cell_data.pack())
         .witness(always_success_script.clone().into_witness())
         .build();
     let always_success_out_point = OutPoint::new(always_success_tx.hash(), 0);
@@ -146,9 +146,9 @@ pub(crate) fn build_chain(tip: BlockNumber) -> (Relayer, OutPoint) {
     let (shared, mut pack) = {
         let dao = genesis_dao_data(vec![&always_success_tx]).unwrap();
         let genesis = BlockBuilder::default()
-            .timestamp(unix_time_as_millis())
+            .timestamp(unix_time_as_millis().pack())
             .dao(dao)
-            .compact_target(difficulty_to_compact(U256::from(1000u64)))
+            .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
             .transaction(always_success_tx)
             .build();
         let epoch_ext = build_genesis_epoch_ext(
@@ -188,11 +188,11 @@ pub(crate) fn build_chain(tip: BlockNumber) -> (Relayer, OutPoint) {
             .input(CellInput::new_cellbase_input(parent.header().number() + 1))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(50000))
+                    .capacity(capacity_bytes!(50000).pack())
                     .lock(always_success_script.to_owned())
                     .build(),
             )
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .witness(Script::default().into_witness())
             .build();
         let header = new_header_builder(&shared, &parent.header()).build();
@@ -273,20 +273,22 @@ pub(crate) fn gen_block(
     let mut block_builder = BlockBuilder::default()
         .parent_hash(parent_header.hash())
         .timestamp(
-            parent_header
+            (parent_header
                 .timestamp()
                 .checked_add_signed(timestamp_delta)
-                .unwrap(),
+                .unwrap())
+            .pack(),
         )
-        .number(number)
+        .number(number.pack())
         .compact_target(
-            epoch
+            (epoch
                 .compact_target()
                 .checked_add_signed(target_delta)
-                .unwrap(),
+                .unwrap())
+            .pack(),
         )
         .dao(dao)
-        .epoch(epoch.number_with_fraction(number))
+        .epoch(epoch.number_with_fraction(number).pack())
         .transactions(txs);
     if let Some(uncle) = uncle_opt {
         block_builder = block_builder.uncle(uncle)
diff --git a/sync/src/relayer/tests/reconstruct_block.rs b/sync/src/relayer/tests/reconstruct_block.rs
index 167356b822..a7e55ec1a7 100644
--- a/sync/src/relayer/tests/reconstruct_block.rs
+++ b/sync/src/relayer/tests/reconstruct_block.rs
@@ -20,12 +20,9 @@ fn test_missing_txs() {
     // Case: miss tx.0
     {
         let compact_block_builder = CompactBlockBuilder::default();
-        let short_ids = prepare
-            .iter()
-            .map(|tx| tx.proposal_short_id())
-            .collect::<Vec<packed::ProposalShortId>>();
+        let short_ids = prepare.iter().map(|tx| tx.proposal_short_id());
         let transactions: Vec<TransactionView> = prepare.iter().skip(1).cloned().collect();
-        let compact = compact_block_builder.short_ids(short_ids).build();
+        let compact = compact_block_builder.short_ids(short_ids.pack()).build();
         assert_eq!(
             relayer.reconstruct_block(
                 &relayer.shared().active_chain(),
@@ -41,10 +38,7 @@ fn test_missing_txs() {
     // Case: miss multiple txs
     {
         let compact_block_builder = CompactBlockBuilder::default();
-        let short_ids = prepare
-            .iter()
-            .map(|tx| tx.proposal_short_id())
-            .collect::<Vec<packed::ProposalShortId>>();
+        let short_ids = prepare.iter().map(|tx| tx.proposal_short_id());
         let transactions: Vec<TransactionView> =
             prepare.iter().skip(1).step_by(2).cloned().collect();
         let missing = prepare
@@ -53,7 +47,7 @@ fn test_missing_txs() {
             .step_by(2)
             .map(|(i, _)| i)
             .collect();
-        let compact = compact_block_builder.short_ids(short_ids).build();
+        let compact = compact_block_builder.short_ids(short_ids.pack()).build();
         assert_eq!(
             relayer.reconstruct_block(
                 &relayer.shared().active_chain(),
@@ -110,7 +104,7 @@ fn test_reconstruct_transactions_and_uncles() {
 
     // BLOCK_VALID
     let ext = packed::BlockExtBuilder::default()
-        .verified(Some(true))
+        .verified(Some(true).pack())
         .build();
 
     let compact = packed::CompactBlock::build_from_block(&block, &prefilled);
@@ -133,7 +127,7 @@ fn test_reconstruct_transactions_and_uncles() {
     {
         let db_txn = relayer.shared().shared().store().begin_transaction();
         db_txn.insert_block(&uncle).unwrap();
-        db_txn.insert_block_ext(&uncle_hash, &ext.into()).unwrap();
+        db_txn.insert_block_ext(&uncle_hash, &ext.unpack()).unwrap();
         db_txn.commit().unwrap();
     }
     relayer.shared().shared().refresh_snapshot();
@@ -155,7 +149,7 @@ fn test_reconstruct_invalid_uncles() {
     let uncle = BlockBuilder::default().build();
     // BLOCK_VALID
     let ext = packed::BlockExtBuilder::default()
-        .verified(Some(false))
+        .verified(Some(false).pack())
         .build();
 
     let block = BlockBuilder::default()
@@ -169,7 +163,7 @@ fn test_reconstruct_invalid_uncles() {
         let db_txn = relayer.shared().shared().store().begin_transaction();
         db_txn.insert_block(&uncle).unwrap();
         db_txn.attach_block(&uncle).unwrap();
-        db_txn.insert_block_ext(&uncle_hash, &ext.into()).unwrap();
+        db_txn.insert_block_ext(&uncle_hash, &ext.unpack()).unwrap();
         db_txn.commit().unwrap();
     }
     relayer.shared().shared().refresh_snapshot();
diff --git a/sync/src/relayer/transactions_process.rs b/sync/src/relayer/transactions_process.rs
index 146cb41be0..11ad489500 100644
--- a/sync/src/relayer/transactions_process.rs
+++ b/sync/src/relayer/transactions_process.rs
@@ -45,7 +45,12 @@ impl<'a> TransactionsProcess<'a> {
             self.message
                 .transactions()
                 .iter()
-                .map(|tx| (tx.transaction().to_entity().into_view(), tx.cycles().into()))
+                .map(|tx| {
+                    (
+                        tx.transaction().to_entity().into_view(),
+                        tx.cycles().unpack(),
+                    )
+                })
                 .filter(|(tx, _)| {
                     !tx_filter.contains(&tx.hash())
                         && unknown_tx_hashes
diff --git a/sync/src/synchronizer/get_headers_process.rs b/sync/src/synchronizer/get_headers_process.rs
index d5e8d7e4d7..12c5041413 100644
--- a/sync/src/synchronizer/get_headers_process.rs
+++ b/sync/src/synchronizer/get_headers_process.rs
@@ -81,12 +81,7 @@ impl<'a> GetHeadersProcess<'a> {
             debug!("headers len={}", headers.len());
 
             let content = packed::SendHeaders::new_builder()
-                .headers(
-                    headers
-                        .into_iter()
-                        .map(|x| x.data())
-                        .collect::<Vec<packed::Header>>(),
-                )
+                .headers(headers.into_iter().map(|x| x.data()).pack())
                 .build();
             let message = packed::SyncMessage::new_builder().set(content).build();
 
diff --git a/sync/src/synchronizer/mod.rs b/sync/src/synchronizer/mod.rs
index fe1bee8004..83aa1213c3 100644
--- a/sync/src/synchronizer/mod.rs
+++ b/sync/src/synchronizer/mod.rs
@@ -236,7 +236,7 @@ impl BlockFetchCMD {
         let assume_valid_target_find = |flag: &mut CanStart| {
             let mut assume_valid_target = shared.assume_valid_target();
             if let Some(ref target) = *assume_valid_target {
-                match shared.header_map().get(&target.into()) {
+                match shared.header_map().get(&target.pack()) {
                     Some(header) => {
                         *flag = CanStart::Ready;
                         info!("assume valid target found in header_map; CKB will start fetch blocks now");
@@ -281,7 +281,7 @@ impl BlockFetchCMD {
 
     fn send_getblocks(v_fetch: Vec<packed::Byte32>, nc: &ServiceControl, peer: PeerIndex) {
         let content = packed::GetBlocks::new_builder()
-            .block_hashes(v_fetch.clone())
+            .block_hashes(v_fetch.clone().pack())
             .build();
         let message = packed::SyncMessage::new_builder().set(content).build();
 
@@ -790,7 +790,7 @@ impl Synchronizer {
         peer: PeerIndex,
     ) {
         let content = packed::GetBlocks::new_builder()
-            .block_hashes(v_fetch.clone())
+            .block_hashes(v_fetch.clone().pack())
             .build();
         let message = packed::SyncMessage::new_builder().set(content).build();
 
diff --git a/sync/src/tests/inflight_blocks.rs b/sync/src/tests/inflight_blocks.rs
index 6f793bfaa7..4511a85821 100644
--- a/sync/src/tests/inflight_blocks.rs
+++ b/sync/src/tests/inflight_blocks.rs
@@ -1,6 +1,7 @@
 use crate::types::InflightBlocks;
 use ckb_constant::sync::BLOCK_DOWNLOAD_TIMEOUT;
 use ckb_types::h256;
+use ckb_types::prelude::*;
 use ckb_types::BlockNumberAndHash;
 use std::collections::HashSet;
 
@@ -9,24 +10,24 @@ fn inflight_blocks_count() {
     let mut inflight_blocks = InflightBlocks::default();
 
     // don't allow 2 peer for one block
-    assert!(inflight_blocks.insert(2.into(), (1, h256!("0x1").into()).into()));
-    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
+    assert!(inflight_blocks.insert(2.into(), (1, h256!("0x1").pack()).into()));
+    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
 
     // peer 1 inflight
-    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
+    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
 
-    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").into()).into()));
+    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").pack()).into()));
 
     assert_eq!(inflight_blocks.total_inflight_count(), 2); // 0x1 0x2
     assert_eq!(inflight_blocks.peer_inflight_count(1.into()), 1);
     assert_eq!(inflight_blocks.peer_inflight_count(2.into()), 1); // one block inflight
     assert_eq!(
         inflight_blocks.inflight_block_by_peer(1.into()).cloned(),
-        Some(HashSet::from_iter(vec![(2, h256!("0x2").into()).into()]))
+        Some(HashSet::from_iter(vec![(2, h256!("0x2").pack()).into()]))
     );
 
     // receive block 0x1
-    inflight_blocks.remove_by_block((1, h256!("0x1").into()).into());
+    inflight_blocks.remove_by_block((1, h256!("0x1").pack()).into());
 
     assert_eq!(inflight_blocks.total_inflight_count(), 1); // 0x2
     assert_eq!(inflight_blocks.peer_inflight_count(1.into()), 1);
@@ -35,7 +36,7 @@ fn inflight_blocks_count() {
         inflight_blocks
             .inflight_block_by_peer(1.into())
             .map(|set| set.iter().collect()),
-        Some(vec![&(2, h256!("0x2").into()).into()])
+        Some(vec![&(2, h256!("0x2").pack()).into()])
     );
 }
 
@@ -43,19 +44,19 @@ fn inflight_blocks_count() {
 fn inflight_blocks_state() {
     let mut inflight_blocks = InflightBlocks::default();
 
-    assert!(inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
-    assert!(!inflight_blocks.insert(2.into(), (1, h256!("0x1").into()).into()));
-    assert!(!inflight_blocks.insert(3.into(), (1, h256!("0x1").into()).into()));
+    assert!(inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
+    assert!(!inflight_blocks.insert(2.into(), (1, h256!("0x1").pack()).into()));
+    assert!(!inflight_blocks.insert(3.into(), (1, h256!("0x1").pack()).into()));
 
     // peer 1 inflight
-    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
-    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").into()).into()));
+    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
+    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").pack()).into()));
 
-    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").into()).into()));
+    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").pack()).into()));
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(1, h256!("0x1").into()).into())
+            .inflight_state_by_block(&(1, h256!("0x1").pack()).into())
             .cloned()
             .map(|state| { state.peer }),
         Some(1.into())
@@ -63,7 +64,7 @@ fn inflight_blocks_state() {
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(3, h256!("0x3").into()).into())
+            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
@@ -74,14 +75,14 @@ fn inflight_blocks_state() {
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(1, h256!("0x1").into()).into())
+            .inflight_state_by_block(&(1, h256!("0x1").pack()).into())
             .map(|state| state.peer),
         None
     );
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(3, h256!("0x3").into()).into())
+            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
@@ -94,45 +95,45 @@ fn inflight_blocks_timeout() {
     let mut inflight_blocks = InflightBlocks::default();
     inflight_blocks.protect_num = 0;
 
-    assert!(inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
-    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").into()).into()));
-    assert!(inflight_blocks.insert(2.into(), (3, h256!("0x3").into()).into()));
-    assert!(!inflight_blocks.insert(1.into(), (3, h256!("0x3").into()).into()));
-    assert!(inflight_blocks.insert(1.into(), (4, h256!("0x4").into()).into()));
-    assert!(inflight_blocks.insert(2.into(), (5, h256!("0x5").into()).into()));
-    assert!(!inflight_blocks.insert(2.into(), (5, h256!("0x5").into()).into()));
+    assert!(inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
+    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").pack()).into()));
+    assert!(inflight_blocks.insert(2.into(), (3, h256!("0x3").pack()).into()));
+    assert!(!inflight_blocks.insert(1.into(), (3, h256!("0x3").pack()).into()));
+    assert!(inflight_blocks.insert(1.into(), (4, h256!("0x4").pack()).into()));
+    assert!(inflight_blocks.insert(2.into(), (5, h256!("0x5").pack()).into()));
+    assert!(!inflight_blocks.insert(2.into(), (5, h256!("0x5").pack()).into()));
 
     _faketime_guard.set_faketime(BLOCK_DOWNLOAD_TIMEOUT + 1);
 
-    assert!(!inflight_blocks.insert(3.into(), (3, h256!("0x3").into()).into()));
-    assert!(!inflight_blocks.insert(3.into(), (2, h256!("0x2").into()).into()));
-    assert!(inflight_blocks.insert(4.into(), (6, h256!("0x6").into()).into()));
-    assert!(inflight_blocks.insert(1.into(), (7, h256!("0x7").into()).into()));
+    assert!(!inflight_blocks.insert(3.into(), (3, h256!("0x3").pack()).into()));
+    assert!(!inflight_blocks.insert(3.into(), (2, h256!("0x2").pack()).into()));
+    assert!(inflight_blocks.insert(4.into(), (6, h256!("0x6").pack()).into()));
+    assert!(inflight_blocks.insert(1.into(), (7, h256!("0x7").pack()).into()));
 
     let peers = inflight_blocks.prune(0);
     assert_eq!(peers, HashSet::from_iter(vec![1.into()]));
-    assert!(inflight_blocks.insert(3.into(), (2, h256!("0x2").into()).into()));
-    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").into()).into()));
+    assert!(inflight_blocks.insert(3.into(), (2, h256!("0x2").pack()).into()));
+    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").pack()).into()));
 
     assert_eq!(inflight_blocks.peer_can_fetch_count(2.into()), 32 >> 4);
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(3, h256!("0x3").into()).into())
+            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(2, h256!("0x2").into()).into())
+            .inflight_state_by_block(&(2, h256!("0x2").pack()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(6, h256!("0x6").into()).into())
+            .inflight_state_by_block(&(6, h256!("0x6").pack()).into())
             .cloned()
             .map(|state| state.peer),
         Some(4.into())
@@ -147,13 +148,13 @@ fn inflight_trace_number_state() {
     let mut inflight_blocks = InflightBlocks::default();
     inflight_blocks.protect_num = 0;
 
-    assert!(inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
-    assert!(inflight_blocks.insert(2.into(), (2, h256!("0x2").into()).into()));
-    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").into()).into()));
-    assert!(inflight_blocks.insert(4.into(), (3, h256!("0x33").into()).into()));
-    assert!(inflight_blocks.insert(5.into(), (4, h256!("0x4").into()).into()));
-    assert!(inflight_blocks.insert(6.into(), (5, h256!("0x5").into()).into()));
-    assert!(inflight_blocks.insert(7.into(), (5, h256!("0x55").into()).into()));
+    assert!(inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
+    assert!(inflight_blocks.insert(2.into(), (2, h256!("0x2").pack()).into()));
+    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").pack()).into()));
+    assert!(inflight_blocks.insert(4.into(), (3, h256!("0x33").pack()).into()));
+    assert!(inflight_blocks.insert(5.into(), (4, h256!("0x4").pack()).into()));
+    assert!(inflight_blocks.insert(6.into(), (5, h256!("0x5").pack()).into()));
+    assert!(inflight_blocks.insert(7.into(), (5, h256!("0x55").pack()).into()));
 
     let list = inflight_blocks.prune(2);
     assert!(list.is_empty());
@@ -171,10 +172,10 @@ fn inflight_trace_number_state() {
             .cloned()
             .collect::<HashSet<BlockNumberAndHash>>(),
         HashSet::from_iter(vec![
-            (1, h256!("0x1").into()).into(),
-            (2, h256!("0x2").into()).into(),
-            (3, h256!("0x3").into()).into(),
-            (3, h256!("0x33").into()).into()
+            (1, h256!("0x1").pack()).into(),
+            (2, h256!("0x2").pack()).into(),
+            (3, h256!("0x3").pack()).into(),
+            (3, h256!("0x33").pack()).into()
         ])
     );
 
@@ -186,10 +187,10 @@ fn inflight_trace_number_state() {
     assert!(inflight_blocks.restart_number == 3);
 
     assert!(inflight_blocks
-        .inflight_state_by_block(&(3, h256!("0x3").into()).into())
+        .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
         .is_none());
     assert!(inflight_blocks
-        .inflight_state_by_block(&(3, h256!("0x33").into()).into())
+        .inflight_state_by_block(&(3, h256!("0x33").pack()).into())
         .is_none());
 
     assert_eq!(inflight_blocks.peer_can_fetch_count(3.into()), 32 >> 1);
diff --git a/sync/src/tests/sync_shared.rs b/sync/src/tests/sync_shared.rs
index 6219bc3eb5..da9dea6e83 100644
--- a/sync/src/tests/sync_shared.rs
+++ b/sync/src/tests/sync_shared.rs
@@ -102,7 +102,7 @@ fn test_insert_parent_unknown_block() {
         let invalid_orphan = block
             .as_advanced_builder()
             .header(block.header())
-            .number(1000)
+            .number(1000.pack())
             .build();
 
         Arc::new(invalid_orphan)
@@ -256,7 +256,7 @@ fn test_switch_valid_fork() {
         .unwrap();
     for _ in 3..shared.active_chain().tip_number() {
         let block = inherit_block(fork_shared.shared(), &parent_header.hash())
-            .timestamp(parent_header.timestamp() + 3)
+            .timestamp((parent_header.timestamp() + 3).pack())
             .build();
         let arc_block = Arc::new(block.clone());
         assert!(fork_shared
@@ -281,7 +281,7 @@ fn test_switch_valid_fork() {
     // Make the fork switch as the main chain.
     for _ in tip_number..tip_number + 2 {
         let block = inherit_block(fork_shared.shared(), &parent_header.hash())
-            .timestamp(parent_header.timestamp() + 3)
+            .timestamp((parent_header.timestamp() + 3).pack())
             .build();
         let arc_block = Arc::new(block.clone());
         assert!(fork_shared
@@ -330,7 +330,7 @@ fn test_sync_relay_collaboration() {
         packed::CompactBlock::build_from_block(&new_block, &std::collections::HashSet::new());
 
     let headers_content = packed::SendHeaders::new_builder()
-        .headers(vec![new_block.header().data()])
+        .headers([new_block.header()].map(|x| x.data()).pack())
         .build();
 
     // keep header process snapshot on old state, this is the bug reason
@@ -404,7 +404,7 @@ fn test_sync_relay_collaboration2() {
         let next_timestamp = next_block.timestamp() + 2;
         let new_block = new_block
             .as_advanced_builder()
-            .timestamp(next_timestamp)
+            .timestamp(next_timestamp.pack())
             .build();
 
         Arc::new(new_block)
@@ -417,7 +417,7 @@ fn test_sync_relay_collaboration2() {
         packed::CompactBlock::build_from_block(&new_block_1, &std::collections::HashSet::new());
 
     let headers_content = packed::SendHeaders::new_builder()
-        .headers(vec![new_block.header().data()])
+        .headers([new_block.header()].map(|x| x.data()).pack())
         .build();
 
     // keep header process snapshot on old state, this is the bug reason
diff --git a/sync/src/tests/synchronizer/basic_sync.rs b/sync/src/tests/synchronizer/basic_sync.rs
index 4337fb5312..1eaa2c3bc9 100644
--- a/sync/src/tests/synchronizer/basic_sync.rs
+++ b/sync/src/tests/synchronizer/basic_sync.rs
@@ -98,14 +98,14 @@ fn setup_node(height: u64) -> (TestNode, Shared) {
         .witness(always_success_script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
         .output(always_success_cell.clone())
-        .output_data(always_success_cell_data)
+        .output_data(always_success_cell_data.pack())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx]).unwrap();
 
     let mut block = BlockBuilder::default()
-        .timestamp(unix_time_as_millis())
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .timestamp(unix_time_as_millis().pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .dao(dao)
         .transaction(always_success_tx)
         .build();
@@ -150,11 +150,11 @@ fn setup_node(height: u64) -> (TestNode, Shared) {
             builder
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(reward.total)
+                        .capacity(reward.total.pack())
                         .lock(always_success_script.to_owned())
                         .build(),
                 )
-                .output_data(Bytes::default())
+                .output_data(Bytes::default().pack())
                 .build()
         };
 
@@ -176,15 +176,15 @@ fn setup_node(height: u64) -> (TestNode, Shared) {
             .chain_root_mmr(block.header().number())
             .get_root()
             .expect("chain root_mmr");
-        let bytes = chain_root.calc_mmr_hash().as_bytes().into();
+        let bytes = chain_root.calc_mmr_hash().as_bytes().pack();
 
         block = BlockBuilder::default()
             .transaction(cellbase)
             .parent_hash(block.header().hash())
-            .number(number)
-            .epoch(epoch.number_with_fraction(number))
-            .timestamp(timestamp)
-            .compact_target(epoch.compact_target())
+            .number(number.pack())
+            .epoch(epoch.number_with_fraction(number).pack())
+            .timestamp(timestamp.pack())
+            .compact_target(epoch.compact_target().pack())
             .dao(dao)
             .extension(Some(bytes))
             .build();
diff --git a/sync/src/tests/synchronizer/functions.rs b/sync/src/tests/synchronizer/functions.rs
index 45892f1663..a63937d727 100644
--- a/sync/src/tests/synchronizer/functions.rs
+++ b/sync/src/tests/synchronizer/functions.rs
@@ -81,8 +81,12 @@ fn create_cellbase(
         builder.build()
     } else {
         builder
-            .output(CellOutputBuilder::default().capacity(reward.total).build())
-            .output_data(Bytes::new())
+            .output(
+                CellOutputBuilder::default()
+                    .capacity(reward.total.pack())
+                    .build(),
+            )
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -110,16 +114,16 @@ fn gen_block(
         .chain_root_mmr(parent_header.number())
         .get_root()
         .expect("chain root_mmr");
-    let bytes = chain_root.calc_mmr_hash().as_bytes().into();
+    let bytes = chain_root.calc_mmr_hash().as_bytes().pack();
 
     BlockBuilder::default()
         .transaction(cellbase)
         .parent_hash(parent_header.hash())
-        .timestamp(now)
-        .epoch(epoch.number_with_fraction(number))
-        .number(number)
-        .compact_target(epoch.compact_target())
-        .nonce(nonce)
+        .timestamp(now.pack())
+        .epoch(epoch.number_with_fraction(number).pack())
+        .number(number.pack())
+        .compact_target(epoch.compact_target().pack())
+        .nonce(nonce.pack())
         .dao(dao)
         .extension(Some(bytes))
         .build()
@@ -626,12 +630,7 @@ fn test_sync_process() {
     );
 
     let sendheaders = SendHeadersBuilder::default()
-        .headers(
-            headers
-                .iter()
-                .map(|h| h.data())
-                .collect::<Vec<packed::Header>>(),
-        )
+        .headers(headers.iter().map(|h| h.data()).pack())
         .build();
 
     let mock_nc = mock_network_context(4);
@@ -690,12 +689,7 @@ fn test_sync_process() {
     insert_block(&synchronizer2.chain, &shared2, 201u128, 201);
     let headers = vec![synchronizer2.shared.active_chain().tip_header()];
     let sendheaders = SendHeadersBuilder::default()
-        .headers(
-            headers
-                .iter()
-                .map(|h| h.data())
-                .collect::<Vec<packed::Header>>(),
-        )
+        .headers(headers.iter().map(|h| h.data()).pack())
         .build();
     assert_eq!(
         HeadersProcess::new(sendheaders.as_reader(), &synchronizer1, peer1, &mock_nc).execute(),
@@ -772,7 +766,7 @@ fn test_chain_sync_timeout() {
 
     let consensus = Consensus::default();
     let block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(3u64)))
+        .compact_target(difficulty_to_compact(U256::from(3u64)).pack())
         .transaction(consensus.genesis_block().transactions()[0].clone())
         .build();
     let consensus = ConsensusBuilder::default().genesis_block(block).build();
@@ -969,7 +963,7 @@ fn test_n_sync_started() {
 
     let consensus = Consensus::default();
     let block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(3u64)))
+        .compact_target(difficulty_to_compact(U256::from(3u64)).pack())
         .transaction(consensus.genesis_block().transactions()[0].clone())
         .build();
     let consensus = ConsensusBuilder::default().genesis_block(block).build();
@@ -1116,7 +1110,9 @@ fn test_fix_last_common_header() {
             .map(|number| graph.get(&f_(number)).cloned().unwrap())
             .map(|block| block.header().data())
             .collect::<Vec<_>>();
-        let sendheaders = SendHeadersBuilder::default().headers(fork_headers).build();
+        let sendheaders = SendHeadersBuilder::default()
+            .headers(fork_headers.pack())
+            .build();
         synchronizer.on_connected(&nc, peer);
         assert!(
             HeadersProcess::new(sendheaders.as_reader(), &synchronizer, peer, &nc)
@@ -1191,7 +1187,7 @@ fn get_blocks_process() {
 
     let genesis_hash = shared.consensus().genesis_hash();
     let message_with_genesis = packed::GetBlocks::new_builder()
-        .block_hashes(vec![genesis_hash])
+        .block_hashes(vec![genesis_hash].pack())
         .build();
 
     let nc = mock_network_context(1);
@@ -1204,7 +1200,7 @@ fn get_blocks_process() {
 
     let hash = shared.snapshot().get_block_hash(1).unwrap();
     let message_with_dup = packed::GetBlocks::new_builder()
-        .block_hashes(vec![hash.clone(), hash])
+        .block_hashes(vec![hash.clone(), hash].pack())
         .build();
 
     let nc = mock_network_context(1);
diff --git a/sync/src/tests/types.rs b/sync/src/tests/types.rs
index 83d23cc69e..e41c0827d1 100644
--- a/sync/src/tests/types.rs
+++ b/sync/src/tests/types.rs
@@ -2,6 +2,7 @@ use ckb_shared::types::HeaderIndexView;
 use ckb_types::{
     core::{BlockNumber, EpochNumberWithFraction, HeaderBuilder},
     packed::Byte32,
+    prelude::*,
     U256,
 };
 use rand::{thread_rng, Rng};
@@ -24,14 +25,9 @@ fn test_get_ancestor_use_skip_list() {
 
     let mut parent_hash = None;
     for number in 0..SKIPLIST_LENGTH {
-        let mut header_builder =
-            HeaderBuilder::default()
-                .number(number)
-                .epoch(EpochNumberWithFraction::new(
-                    number / 1000,
-                    number % 1000,
-                    1000,
-                ));
+        let mut header_builder = HeaderBuilder::default()
+            .number(number.pack())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack());
         if let Some(parent_hash) = parent_hash.take() {
             header_builder = header_builder.parent_hash(parent_hash);
         }
diff --git a/sync/src/tests/util.rs b/sync/src/tests/util.rs
index 4a314a3832..8f37b7e7bf 100644
--- a/sync/src/tests/util.rs
+++ b/sync/src/tests/util.rs
@@ -71,14 +71,14 @@ pub fn inherit_block(shared: &Shared, parent_hash: &Byte32) -> BlockBuilder {
         .chain_root_mmr(parent_number)
         .get_root()
         .expect("chain root_mmr");
-    let bytes = chain_root.calc_mmr_hash().as_bytes().into();
+    let bytes = chain_root.calc_mmr_hash().as_bytes().pack();
 
     BlockBuilder::default()
         .parent_hash(parent_hash.to_owned())
-        .number(parent.header().number() + 1)
-        .timestamp(parent.header().timestamp() + 1)
-        .epoch(epoch.number_with_fraction(parent_number + 1))
-        .compact_target(epoch.compact_target())
+        .number((parent.header().number() + 1).pack())
+        .timestamp((parent.header().timestamp() + 1).pack())
+        .epoch(epoch.number_with_fraction(parent_number + 1).pack())
+        .compact_target(epoch.compact_target().pack())
         .dao(dao)
         .transaction(cellbase)
         .extension(Some(bytes))
diff --git a/sync/src/types/mod.rs b/sync/src/types/mod.rs
index 873882efc9..476a5c308b 100644
--- a/sync/src/types/mod.rs
+++ b/sync/src/types/mod.rs
@@ -1946,7 +1946,7 @@ impl ActiveChain {
         );
         let locator_hash = self.get_locator(block_number_and_hash);
         let content = packed::GetHeaders::new_builder()
-            .block_locator_hashes(locator_hash)
+            .block_locator_hashes(locator_hash.pack())
             .hash_stop(packed::Byte32::zero())
             .build();
         let message = packed::SyncMessage::new_builder().set(content).build();
diff --git a/test/src/assertion/reward_assertion.rs b/test/src/assertion/reward_assertion.rs
index 6825700c5a..229bf9bd3f 100644
--- a/test/src/assertion/reward_assertion.rs
+++ b/test/src/assertion/reward_assertion.rs
@@ -1,6 +1,7 @@
 use crate::Node;
 use ckb_types::core::{BlockEconomicState, BlockView, Capacity, Ratio, TransactionView};
 use ckb_types::packed::{Byte32, OutPoint, ProposalShortId};
+use ckb_types::prelude::*;
 use std::collections::HashMap;
 
 pub fn check_fee(node: &Node) {
@@ -112,7 +113,7 @@ impl RewardChecker {
     fn apply_new_transaction(&mut self, tx: &TransactionView) {
         for (index, output) in tx.outputs().into_iter().enumerate() {
             let out_point = OutPoint::new(tx.hash(), index as u32);
-            let capacity: u64 = output.capacity().into();
+            let capacity: u64 = output.capacity().unpack();
             self.cells_capacity.insert(out_point, capacity);
         }
 
diff --git a/test/src/node.rs b/test/src/node.rs
index 1931666e95..ad25d7fe89 100644
--- a/test/src/node.rs
+++ b/test/src/node.rs
@@ -19,9 +19,7 @@ use ckb_types::{
         self, capacity_bytes, BlockBuilder, BlockNumber, BlockView, Capacity, HeaderView,
         ScriptHashType, TransactionView,
     },
-    packed::{
-        self, Block, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, Script,
-    },
+    packed::{Block, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, Script},
     prelude::*,
 };
 use std::borrow::{Borrow, BorrowMut};
@@ -239,7 +237,7 @@ impl Node {
         let always_success_code_hash = CellOutput::calc_data_hash(&always_success_raw);
         Script::new_builder()
             .code_hash(always_success_code_hash)
-            .hash_type(ScriptHashType::Data)
+            .hash_type(ScriptHashType::Data.into())
             .build()
     }
 
@@ -265,7 +263,7 @@ impl Node {
         let always_failure_code_hash = CellOutput::calc_data_hash(&always_failure_raw);
         Script::new_builder()
             .code_hash(always_failure_code_hash)
-            .hash_type(ScriptHashType::Data)
+            .hash_type(ScriptHashType::Data.into())
             .build()
     }
 
@@ -368,7 +366,10 @@ impl Node {
         // the new block in main fork which timestamp is greater than
         // or equal to the current time.
         let timestamp = block.timestamp();
-        let uncle = block.as_advanced_builder().timestamp(timestamp + 1).build();
+        let uncle = block
+            .as_advanced_builder()
+            .timestamp((timestamp - 1).pack())
+            .build();
         (block, uncle)
     }
 
@@ -403,7 +404,7 @@ impl Node {
         let res = self
             .rpc_client()
             .send_transaction_result(transaction.data().into())?
-            .into();
+            .pack();
         Ok(res)
     }
 
@@ -595,11 +596,11 @@ impl Node {
             .cell_dep(always_success_cell_dep)
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity)
+                    .capacity(capacity.pack())
                     .lock(always_success_script)
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .input(CellInput::new(OutPoint::new(hash, index), since))
             .build()
     }
@@ -621,11 +622,11 @@ impl Node {
             .cell_dep(always_failure_cell_dep)
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100))
+                    .capacity(capacity_bytes!(100).pack())
                     .lock(always_failure_script)
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .input(CellInput::new(OutPoint::new(hash, 0), 0))
             .build()
     }
diff --git a/test/src/rpc.rs b/test/src/rpc.rs
index e1634141f4..bb4b9a81dc 100644
--- a/test/src/rpc.rs
+++ b/test/src/rpc.rs
@@ -15,7 +15,7 @@ use ckb_types::core::{
     BlockNumber as CoreBlockNumber, Capacity as CoreCapacity, EpochNumber as CoreEpochNumber,
     Version as CoreVersion,
 };
-use ckb_types::{packed::Byte32, H256};
+use ckb_types::{packed::Byte32, prelude::*, H256};
 use lazy_static::lazy_static;
 
 lazy_static! {
@@ -42,13 +42,13 @@ impl RpcClient {
 
     pub fn get_block(&self, hash: Byte32) -> Option<BlockView> {
         self.inner
-            .get_block(hash.into())
+            .get_block(hash.unpack())
             .expect("rpc call get_block")
     }
 
     pub fn get_fork_block(&self, hash: Byte32) -> Option<BlockView> {
         self.inner
-            .get_fork_block(hash.into())
+            .get_fork_block(hash.unpack())
             .expect("rpc call get_fork_block")
     }
 
@@ -60,7 +60,7 @@ impl RpcClient {
 
     pub fn get_header(&self, hash: Byte32) -> Option<HeaderView> {
         self.inner
-            .get_header(hash.into())
+            .get_header(hash.unpack())
             .expect("rpc call get_header")
     }
 
@@ -72,7 +72,7 @@ impl RpcClient {
 
     pub fn get_block_filter(&self, hash: Byte32) -> Option<BlockFilter> {
         self.inner
-            .get_block_filter(hash.into())
+            .get_block_filter(hash.unpack())
             .expect("rpc call get_block_filter")
     }
 
@@ -86,13 +86,13 @@ impl RpcClient {
         verbosity: u32,
     ) -> TransactionWithStatusResponse {
         self.inner
-            .get_transaction(hash.into(), Some(verbosity.into()), None)
+            .get_transaction(hash.unpack(), Some(verbosity.into()), None)
             .expect("rpc call get_transaction")
     }
 
     pub fn get_pool_tx_detail_info(&self, hash: Byte32) -> PoolTxDetailInfo {
         self.inner
-            .get_pool_tx_detail_info(hash.into())
+            .get_pool_tx_detail_info(hash.unpack())
             .expect("rpc call get_transaction_tx_pool_details")
     }
 
@@ -100,7 +100,7 @@ impl RpcClient {
         self.inner
             .get_block_hash(number.into())
             .expect("rpc call get_block_hash")
-            .map(|x| x.into())
+            .map(|x| x.pack())
     }
 
     pub fn get_tip_header(&self) -> HeaderView {
@@ -209,7 +209,7 @@ impl RpcClient {
     }
 
     pub fn submit_block(&self, work_id: String, block: Block) -> Result<Byte32, AnyError> {
-        self.inner.submit_block(work_id, block).map(|x| x.into())
+        self.inner.submit_block(work_id, block).map(|x| x.pack())
     }
 
     pub fn get_blockchain_info(&self) -> ChainInfo {
@@ -220,14 +220,14 @@ impl RpcClient {
 
     pub fn get_block_median_time(&self, block_hash: Byte32) -> Option<Timestamp> {
         self.inner
-            .get_block_median_time(block_hash.into())
+            .get_block_median_time(block_hash.unpack())
             .expect("rpc call get_block_median_time")
     }
 
     pub fn send_transaction(&self, tx: Transaction) -> Byte32 {
         self.send_transaction_result(tx)
             .expect("rpc call send_transaction")
-            .into()
+            .pack()
     }
 
     pub fn send_transaction_result(&self, tx: Transaction) -> Result<H256, AnyError> {
@@ -237,7 +237,7 @@ impl RpcClient {
 
     pub fn remove_transaction(&self, tx_hash: Byte32) -> bool {
         self.inner
-            .remove_transaction(tx_hash.into())
+            .remove_transaction(tx_hash.unpack())
             .expect("rpc call remove_transaction")
     }
 
@@ -277,12 +277,12 @@ impl RpcClient {
         self.inner
             .process_block_without_verify(block, broadcast)
             .expect("rpc call process_block_without verify")
-            .map(|x| x.into())
+            .map(|x| x.pack())
     }
 
     pub fn truncate(&self, target_tip_hash: Byte32) {
         self.inner()
-            .truncate(target_tip_hash.into())
+            .truncate(target_tip_hash.unpack())
             .expect("rpc call truncate")
     }
 
@@ -290,14 +290,14 @@ impl RpcClient {
         self.inner()
             .generate_block()
             .expect("rpc call generate_block")
-            .into()
+            .pack()
     }
 
     pub fn generate_block_with_template(&self, block_template: BlockTemplate) -> Byte32 {
         self.inner()
             .generate_block_with_template(block_template)
             .expect("rpc call generate_block_with_template")
-            .into()
+            .pack()
     }
 
     pub fn calculate_dao_maximum_withdraw(
@@ -306,14 +306,14 @@ impl RpcClient {
         hash: Byte32,
     ) -> CoreCapacity {
         self.inner()
-            .calculate_dao_maximum_withdraw(out_point, hash.into())
+            .calculate_dao_maximum_withdraw(out_point, hash.unpack())
             .expect("rpc call calculate_dao_maximum_withdraw")
             .into()
     }
 
     pub fn get_block_economic_state(&self, hash: Byte32) -> Option<BlockEconomicState> {
         self.inner()
-            .get_block_economic_state(hash.into())
+            .get_block_economic_state(hash.unpack())
             .expect("rpc call get_block_economic_state")
     }
 
@@ -321,7 +321,7 @@ impl RpcClient {
         self.inner()
             .notify_transaction(tx)
             .expect("rpc call send_transaction")
-            .into()
+            .pack()
     }
 
     pub fn tx_pool_ready(&self) -> bool {
diff --git a/test/src/specs/alert/alert_propagation.rs b/test/src/specs/alert/alert_propagation.rs
index 3af797ecd1..d5e8164753 100644
--- a/test/src/specs/alert/alert_propagation.rs
+++ b/test/src/specs/alert/alert_propagation.rs
@@ -44,9 +44,9 @@ impl Spec for AlertPropagation {
         let id1: u32 = 42;
         let warning1: Bytes = b"pretend we are in dangerous status".to_vec().into();
         let raw_alert = RawAlert::new_builder()
-            .id(id1)
-            .message(&warning1)
-            .notice_until(notice_until)
+            .id(id1.pack())
+            .message(warning1.pack())
+            .notice_until(notice_until.pack())
             .build();
         let alert = create_alert(raw_alert, &self.privkeys);
         node0.rpc_client().send_alert(alert.clone().into());
@@ -74,10 +74,10 @@ impl Spec for AlertPropagation {
         let id2: u32 = 43;
         let warning2: Bytes = b"alert is canceled".to_vec().into();
         let raw_alert2 = RawAlert::new_builder()
-            .id(id2)
-            .cancel(id1)
-            .message(&warning2)
-            .notice_until(notice_until)
+            .id(id2.pack())
+            .cancel(id1.pack())
+            .message(warning2.pack())
+            .notice_until(notice_until.pack())
             .build();
         let alert2 = create_alert(raw_alert2, &self.privkeys);
         node0.rpc_client().send_alert(alert2.into());
@@ -141,7 +141,7 @@ impl Spec for AlertPropagation {
 }
 
 fn create_alert(raw_alert: RawAlert, privkeys: &[Privkey]) -> Alert {
-    let msg: Message = raw_alert.calc_alert_hash().into();
+    let msg: Message = raw_alert.calc_alert_hash().unpack();
     let signatures = privkeys
         .iter()
         .take(2)
@@ -151,11 +151,11 @@ fn create_alert(raw_alert: RawAlert, privkeys: &[Privkey]) -> Alert {
                 .expect("Sign failed")
                 .serialize()
                 .into();
-            data.into()
+            data.pack()
         })
         .collect::<Vec<packed::Bytes>>();
     Alert::new_builder()
         .raw(raw_alert)
-        .signatures(signatures)
+        .signatures(signatures.pack())
         .build()
 }
diff --git a/test/src/specs/consensus/insufficient_reward.rs b/test/src/specs/consensus/insufficient_reward.rs
index 831759eccd..45d1e6bf3d 100644
--- a/test/src/specs/consensus/insufficient_reward.rs
+++ b/test/src/specs/consensus/insufficient_reward.rs
@@ -2,7 +2,6 @@ use crate::global::VENDOR_PATH;
 use crate::specs::spec_name;
 use crate::{Node, Spec};
 
-use ckb_types::packed::Script;
 use ckb_types::{
     core::{capacity_bytes, Capacity},
     packed::CellOutput,
@@ -47,8 +46,8 @@ impl Spec for InsufficientReward {
 
         // build a block with insufficient reward
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(1))
-            .lock(Script::default())
+            .capacity(capacity_bytes!(1).pack())
+            .lock(Default::default())
             .build();
         let cellbase = new_block_builder.clone().build().transactions()[0]
             .as_advanced_builder()
diff --git a/test/src/specs/dao/dao_tx.rs b/test/src/specs/dao/dao_tx.rs
index af9f4f8db5..64eec88332 100644
--- a/test/src/specs/dao/dao_tx.rs
+++ b/test/src/specs/dao/dao_tx.rs
@@ -27,7 +27,7 @@ impl Spec for WithdrawDAO {
 
         let withdrawal = user.withdraw();
         let since = EpochNumberWithFraction::from_full_value(
-            withdrawal.inputs().get(0).unwrap().since().into(),
+            withdrawal.inputs().get(0).unwrap().since().unpack(),
         );
         goto_target_point(node, since);
         ensure_committed(node, &withdrawal);
@@ -59,9 +59,12 @@ impl Spec for WithdrawDAOWithOverflowCapacity {
                 .outputs()
                 .into_iter()
                 .map(|cell_output| {
-                    let old_capacity: Capacity = cell_output.capacity().into();
+                    let old_capacity: Capacity = cell_output.capacity().unpack();
                     let new_capacity = old_capacity.safe_add(Capacity::one()).unwrap();
-                    cell_output.as_builder().capacity(new_capacity).build()
+                    cell_output
+                        .as_builder()
+                        .capacity(new_capacity.pack())
+                        .build()
                 })
                 .collect();
             withdrawal
@@ -70,7 +73,7 @@ impl Spec for WithdrawDAOWithOverflowCapacity {
                 .build()
         };
         let since = EpochNumberWithFraction::from_full_value(
-            withdrawal.inputs().get(0).unwrap().since().into(),
+            withdrawal.inputs().get(0).unwrap().since().unpack(),
         );
         goto_target_point(node, since);
         assert_send_transaction_fail(node, &invalid_withdrawal, "Overflow");
diff --git a/test/src/specs/dao/dao_user.rs b/test/src/specs/dao/dao_user.rs
index b54fd1c7d9..aa729e8476 100644
--- a/test/src/specs/dao/dao_user.rs
+++ b/test/src/specs/dao/dao_user.rs
@@ -2,7 +2,7 @@ use crate::utils::since_from_absolute_epoch_number;
 use crate::{Node, TXOSet, TXO};
 use ckb_chain_spec::OUTPUT_INDEX_DAO;
 use ckb_types::core::{EpochNumberWithFraction, HeaderView};
-use ckb_types::packed::{self, WitnessArgs};
+use ckb_types::packed::WitnessArgs;
 use ckb_types::{
     bytes::Bytes,
     core::{ScriptHashType, TransactionBuilder, TransactionView},
@@ -41,7 +41,7 @@ impl<'a> DAOUser<'a> {
             .iter()
             .map(|txo| CellInput::new(txo.out_point(), 0))
             .collect::<Vec<_>>();
-        let output_data: packed::Bytes = Bytes::from(&[0u8; 8][..]).into();
+        let output_data = Bytes::from(&[0u8; 8][..]).pack();
         let outputs = {
             // TRICK: When we change the always_outputs to deposit_outputs, the always_output's
             // capacity will be insufficient. So here uses part of always_outputs' capacity
@@ -51,9 +51,9 @@ impl<'a> DAOUser<'a> {
             (0..outputs_len)
                 .map(|_| {
                     CellOutput::new_builder()
-                        .capacity(capacity)
+                        .capacity(capacity.pack())
                         .lock(node.always_success_script())
-                        .type_(Some(self.dao_type_script()))
+                        .type_(Some(self.dao_type_script()).pack())
                         .build()
                 })
                 .collect::<Vec<_>>()
@@ -68,7 +68,7 @@ impl<'a> DAOUser<'a> {
             .inputs(inputs)
             .outputs(outputs)
             .outputs_data(outputs_data)
-            .witness(packed::Bytes::default())
+            .witness(Default::default())
             .build();
         self.deposit_utxo = TXOSet::from(&tx);
         tx
@@ -83,14 +83,14 @@ impl<'a> DAOUser<'a> {
             .map(|(txo, _)| CellInput::new(txo.out_point(), 0));
         let outputs = deposit_utxo_headers.iter().map(|(txo, _)| {
             CellOutput::new_builder()
-                .capacity(txo.capacity())
+                .capacity(txo.capacity().pack())
                 .lock(txo.lock())
                 .type_(txo.type_())
                 .build()
         });
         let outputs_data = deposit_utxo_headers.iter().map(|(_, header)| {
             let deposit_number = header.number();
-            Bytes::from(deposit_number.to_le_bytes().to_vec()).into()
+            Bytes::from(deposit_number.to_le_bytes().to_vec()).pack()
         });
         let cell_deps = vec![node.always_success_cell_dep(), self.dao_cell_dep()];
         // NOTE: dao.c uses `deposit_header` to ensure the prepare_output.capacity == deposit_output.capacity
@@ -108,10 +108,10 @@ impl<'a> DAOUser<'a> {
                     .position(|hash| hash == &header.hash())
                     .unwrap() as u64;
                 WitnessArgs::new_builder()
-                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())))
+                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())).pack())
                     .build()
                     .as_bytes()
-                    .into()
+                    .pack()
             })
             .collect::<Vec<_>>();
         let tx = TransactionBuilder::default()
@@ -148,7 +148,7 @@ impl<'a> DAOUser<'a> {
             })
             .sum::<u64>();
         let output = CellOutput::new_builder()
-            .capacity(output_capacity)
+            .capacity(output_capacity.pack())
             .lock(node.always_success_script())
             .build();
         let cell_deps = vec![node.always_success_cell_dep(), self.dao_cell_dep()];
@@ -167,10 +167,10 @@ impl<'a> DAOUser<'a> {
                     .position(|hash| hash == &header.hash())
                     .unwrap() as u64;
                 WitnessArgs::new_builder()
-                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())))
+                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())).pack())
                     .build()
                     .as_bytes()
-                    .into()
+                    .pack()
             })
             .collect::<Vec<_>>();
         let tx = TransactionBuilder::default()
@@ -179,7 +179,7 @@ impl<'a> DAOUser<'a> {
             .cell_deps(cell_deps)
             .header_deps(header_deps)
             .witnesses(witnesses)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         self.withdraw_utxo = TXOSet::from(&tx);
         tx
@@ -188,7 +188,7 @@ impl<'a> DAOUser<'a> {
     pub fn dao_type_script(&self) -> Script {
         Script::new_builder()
             .code_hash(self.node.consensus().dao_type_hash())
-            .hash_type(ScriptHashType::Type)
+            .hash_type(ScriptHashType::Type.into())
             .build()
     }
 
@@ -220,7 +220,7 @@ impl<'a> DAOUser<'a> {
                 let header = self
                     .node
                     .rpc_client()
-                    .get_header(block_hash.into())
+                    .get_header(block_hash.pack())
                     .expect("get utxo transaction block header")
                     .into();
                 (txo, header)
@@ -240,7 +240,7 @@ impl<'a> DAOUser<'a> {
                 .expect("get deposit transaction block hash");
             let deposit_header = node
                 .rpc_client()
-                .get_header(deposit_hash.into())
+                .get_header(deposit_hash.pack())
                 .expect("get deposit transaction block header");
             EpochNumberWithFraction::from_full_value(deposit_header.inner.epoch.value())
         };
diff --git a/test/src/specs/dao/dao_verifier.rs b/test/src/specs/dao/dao_verifier.rs
index 989a321180..b2b1fab86a 100644
--- a/test/src/specs/dao/dao_verifier.rs
+++ b/test/src/specs/dao/dao_verifier.rs
@@ -5,6 +5,7 @@ use ckb_dao_utils::extract_dao_data;
 use ckb_jsonrpc_types::EpochView;
 use ckb_types::core::{BlockEconomicState, BlockNumber, BlockView, Capacity, TransactionView};
 use ckb_types::packed::{Byte32, CellOutput, OutPoint};
+use ckb_types::prelude::Unpack;
 use ckb_util::Mutex;
 use std::collections::HashMap;
 
@@ -147,7 +148,7 @@ impl DAOVerifier {
                     && tx_index == 0
                     && output.lock().args().raw_data() == satoshi_pubkey_hash.0[..]
                 {
-                    sum += Into::<Capacity>::into(&output.capacity())
+                    sum += Unpack::<Capacity>::unpack(&output.capacity())
                         .safe_mul_ratio(satoshi_cell_occupied_ratio)
                         .unwrap()
                         .as_u64();
@@ -218,7 +219,7 @@ impl DAOVerifier {
                     let prepare_tx = self.get_transaction(&o.tx_hash());
                     let deposit_out_point = prepare_tx
                         .inputs()
-                        .get(o.index().into())
+                        .get(o.index().unpack())
                         .unwrap()
                         .previous_output();
                     let deposit_header_number =
@@ -245,7 +246,7 @@ impl DAOVerifier {
         let input_tx = self.get_transaction(&out_point.tx_hash());
         let input_data = input_tx
             .outputs_data()
-            .get(out_point.index().into())
+            .get(out_point.index().unpack())
             .unwrap();
         if input_data.len() != 8 {
             return false;
@@ -332,12 +333,12 @@ impl DAOVerifier {
 
     fn get_output(&self, out_point: &OutPoint) -> CellOutput {
         self.get_transaction(&out_point.tx_hash())
-            .output(out_point.index().into())
+            .output(out_point.index().unpack())
             .expect("exist")
     }
 
     fn get_output_capacity(&self, out_point: &OutPoint) -> u64 {
-        self.get_output(out_point).capacity().into()
+        self.get_output(out_point).capacity().unpack()
     }
 
     fn get_output_occupied_capacity(&self, out_point: &OutPoint) -> u64 {
@@ -345,12 +346,12 @@ impl DAOVerifier {
         let satoshi_cell_occupied_ratio = self.consensus.satoshi_cell_occupied_ratio;
         let (output, data) = self
             .get_transaction(&out_point.tx_hash())
-            .output_with_data(out_point.index().into())
+            .output_with_data(out_point.index().unpack())
             .expect("exist");
-        if Into::<u32>::into(&out_point.index()) == 0
+        if Unpack::<u32>::unpack(&out_point.index()) == 0
             && output.lock().args().raw_data() == satoshi_pubkey_hash.0[..]
         {
-            Into::<Capacity>::into(&output.capacity())
+            Unpack::<Capacity>::unpack(&output.capacity())
                 .safe_mul_ratio(satoshi_cell_occupied_ratio)
                 .unwrap()
                 .as_u64()
diff --git a/test/src/specs/dao/satoshi_dao_occupied.rs b/test/src/specs/dao/satoshi_dao_occupied.rs
index 74ae15a3cc..5756d25ceb 100644
--- a/test/src/specs/dao/satoshi_dao_occupied.rs
+++ b/test/src/specs/dao/satoshi_dao_occupied.rs
@@ -35,7 +35,7 @@ impl Spec for DAOWithSatoshiCellOccupied {
 
         let withdrawal = user.withdraw();
         let since = EpochNumberWithFraction::from_full_value(
-            withdrawal.inputs().get(0).unwrap().since().into(),
+            withdrawal.inputs().get(0).unwrap().since().unpack(),
         );
         goto_target_point(node, since);
         ensure_committed(node, &withdrawal);
@@ -95,7 +95,7 @@ impl Spec for SpendSatoshiCell {
             0,
         );
         let output = CellOutput::new_builder()
-            .capacity(satoshi_cell_occupied)
+            .capacity(satoshi_cell_occupied.pack())
             .lock(always_success_cell().2.clone())
             .build();
 
@@ -103,17 +103,20 @@ impl Spec for SpendSatoshiCell {
             .cell_deps(vec![node0.always_success_cell_dep()])
             .input(satoshi_input)
             .output(output)
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .build();
         let tx_hash = transaction.hash();
         let sig = self
             .privkey
-            .sign_recoverable(&(&tx_hash).into())
+            .sign_recoverable(&tx_hash.unpack())
             .expect("sign");
         let mut witness_vec = sig.serialize();
         witness_vec.extend_from_slice(&self.pubkey.serialize());
         let witness = Bytes::from(witness_vec);
-        let transaction = transaction.as_advanced_builder().witness(witness).build();
+        let transaction = transaction
+            .as_advanced_builder()
+            .witness(witness.pack())
+            .build();
 
         node0.mine(1);
         node0
@@ -149,7 +152,7 @@ fn issue_satoshi_cell() -> IssuedCell {
         .2
         .clone()
         .as_builder()
-        .args(Bytes::from(&SATOSHI_PUBKEY_HASH.0[..]))
+        .args(Bytes::from(&SATOSHI_PUBKEY_HASH.0[..]).pack())
         .build();
     IssuedCell {
         capacity: SATOSHI_CELL_CAPACITY,
diff --git a/test/src/specs/hardfork/v2021/cell_deps.rs b/test/src/specs/hardfork/v2021/cell_deps.rs
index c6f66e9f71..929a2e2f54 100644
--- a/test/src/specs/hardfork/v2021/cell_deps.rs
+++ b/test/src/specs/hardfork/v2021/cell_deps.rs
@@ -169,12 +169,12 @@ impl NewScript {
         let original_data = node.always_success_raw_data();
         let data = packed::Bytes::new_builder()
             .extend(original_data.as_ref().iter().map(|x| (*x).into()))
-            .push(id)
+            .push(id.into())
             .build();
         let tx = Self::deploy(node, &data, inputs, type_script_opt);
         let cell_dep = packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
-            .dep_type(core::DepType::Code)
+            .dep_type(core::DepType::Code.into())
             .build();
         let data_hash = packed::CellOutput::calc_data_hash(&data.raw_data());
         let type_hash = tx
@@ -219,7 +219,7 @@ impl NewScript {
         };
         let cell_input = inputs.next().unwrap();
         let cell_output = packed::CellOutput::new_builder()
-            .type_(Some(type_script))
+            .type_(Some(type_script).pack())
             .build_exact_capacity(core::Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -249,14 +249,14 @@ impl NewScript {
         };
         packed::Script::new_builder()
             .code_hash(self.data_hash.clone())
-            .hash_type(hash_type)
+            .hash_type(hash_type.into())
             .build()
     }
 
     fn as_type_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(core::ScriptHashType::Type)
+            .hash_type(core::ScriptHashType::Type.into())
             .build()
     }
 }
@@ -375,7 +375,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
 
     fn wait_block_assembler_reset(&self, block_hash: Byte32) {
         self.node
-            .new_block_with_blocking(|template| template.parent_hash != (&block_hash).into());
+            .new_block_with_blocking(|template| template.parent_hash != block_hash.unpack());
     }
 }
 
@@ -443,7 +443,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         type_script: &NewScript,
     ) -> TransactionView {
         let output = packed::CellOutput::new_builder()
-            .type_(Some(type_script.as_data_script(0)))
+            .type_(Some(type_script.as_data_script(0)).pack())
             .build_exact_capacity(core::Capacity::bytes(data_script.data().len()).unwrap())
             .unwrap();
         let tx = TransactionView::new_advanced_builder()
@@ -460,7 +460,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
     fn convert_tx_to_code_cellep(tx: &TransactionView) -> packed::CellDep {
         packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
-            .dep_type(core::DepType::Code)
+            .dep_type(core::DepType::Code.into())
             .build()
     }
 
@@ -469,14 +469,13 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         inputs: &mut impl Iterator<Item = packed::CellInput>,
         dep_txs: &[&TransactionView],
     ) -> packed::CellDep {
-        let dep_data: packed::Bytes = Into::<packed::OutPointVec>::into(
-            dep_txs
-                .iter()
-                .map(|tx| packed::OutPoint::new(tx.hash(), 0))
-                .collect::<Vec<_>>(),
-        )
-        .as_bytes()
-        .into();
+        let dep_data = dep_txs
+            .iter()
+            .map(|tx| packed::OutPoint::new(tx.hash(), 0))
+            .collect::<Vec<_>>()
+            .pack()
+            .as_bytes()
+            .pack();
         let dep_output = packed::CellOutput::new_builder()
             .build_exact_capacity(core::Capacity::bytes(dep_data.len()).unwrap())
             .unwrap();
@@ -489,7 +488,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         Self::submit_transaction_until_committed_to(node, &tx);
         packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
-            .dep_type(core::DepType::DepGroup)
+            .dep_type(core::DepType::DepGroup.into())
             .build()
     }
 }
@@ -504,7 +503,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
 
     fn get_previous_output(&self, cell_input: &packed::CellInput) -> rpc::CellOutput {
         let previous_output = cell_input.previous_output();
-        let previous_output_index: usize = previous_output.index().into();
+        let previous_output_index: usize = previous_output.index().unpack();
         if let Either::Left(tx) = self
             .node
             .rpc_client()
@@ -526,7 +525,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         let new_script = &self.deps.default_script;
         let input_cell = self.get_previous_output(&cell_input);
         let cell_output = packed::CellOutput::new_builder()
-            .capacity(input_cell.capacity.value())
+            .capacity(input_cell.capacity.value().pack())
             .lock(new_script.as_data_script(0))
             .build();
         let tx = TransactionView::new_advanced_builder()
@@ -534,7 +533,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
             .cell_dep(new_script.cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -546,16 +545,16 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         let new_script = &self.deps.default_script;
         let input_cell = self.get_previous_output(&cell_input);
         let cell_output = packed::CellOutput::new_builder()
-            .capacity(input_cell.capacity.value())
+            .capacity(input_cell.capacity.value().pack())
             .lock(self.node.always_success_script())
-            .type_(Some(new_script.as_data_script(0)))
+            .type_(Some(new_script.as_data_script(0)).pack())
             .build();
         let tx = TransactionView::new_advanced_builder()
             .cell_dep(self.node.always_success_cell_dep())
             .cell_dep(new_script.cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -567,7 +566,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         let new_script = &self.deps.default_script;
         let input_cell = self.get_previous_output(&cell_input);
         let cell_output = packed::CellOutput::new_builder()
-            .capacity(input_cell.capacity.value())
+            .capacity(input_cell.capacity.value().pack())
             .lock(new_script.as_type_script())
             .build();
         let tx = TransactionView::new_advanced_builder()
@@ -575,7 +574,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
             .cell_dep(new_script.cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -587,16 +586,16 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         let new_script = &self.deps.default_script;
         let input_cell = self.get_previous_output(&cell_input);
         let cell_output = packed::CellOutput::new_builder()
-            .capacity(input_cell.capacity.value())
+            .capacity(input_cell.capacity.value().pack())
             .lock(self.node.always_success_script())
-            .type_(Some(new_script.as_type_script()))
+            .type_(Some(new_script.as_type_script()).pack())
             .build();
         let tx = TransactionView::new_advanced_builder()
             .cell_dep(self.node.always_success_cell_dep())
             .cell_dep(new_script.cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -627,11 +626,11 @@ impl<'a> CheckCellDepsTestRunner<'a> {
                     (HT::Data, ST::Lock) => cob.lock(new_script.as_data_script(0)),
                     (HT::Data, ST::Type) => cob
                         .lock(self.node.always_success_script())
-                        .type_(Some(new_script.as_data_script(0))),
+                        .type_(Some(new_script.as_data_script(0)).pack()),
                     (HT::Type, ST::Lock) => cob.lock(new_script.as_type_script()),
                     (HT::Type, ST::Type) => cob
                         .lock(self.node.always_success_script())
-                        .type_(Some(new_script.as_type_script())),
+                        .type_(Some(new_script.as_type_script()).pack()),
                 }
             }
         }
@@ -700,7 +699,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         }
         .input(cell_input)
         .output(cell_output)
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
         self.adjust_tip_before_test();
         if let Some(errmsg) = expected.error_message() {
diff --git a/test/src/specs/hardfork/v2021/vm_b_extension.rs b/test/src/specs/hardfork/v2021/vm_b_extension.rs
index 8c89d1d260..22882c4140 100644
--- a/test/src/specs/hardfork/v2021/vm_b_extension.rs
+++ b/test/src/specs/hardfork/v2021/vm_b_extension.rs
@@ -80,11 +80,11 @@ impl Spec for CheckVmBExtension {
 
 impl BExtScript {
     fn new(node: &Node, cell_input: packed::CellInput) -> Self {
-        let data: packed::Bytes = include_bytes!("../../../../../script/testdata/cpop_lock").into();
+        let data: packed::Bytes = include_bytes!("../../../../../script/testdata/cpop_lock").pack();
         let tx = Self::deploy(node, &data, cell_input);
         let cell_dep = packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
-            .dep_type(DepType::Code)
+            .dep_type(DepType::Code.into())
             .build();
         let data_hash = packed::CellOutput::calc_data_hash(&data.raw_data());
         let type_hash = tx
@@ -105,7 +105,7 @@ impl BExtScript {
         let type_script = node.always_success_script();
         let tx_template = TransactionView::new_advanced_builder();
         let cell_output = packed::CellOutput::new_builder()
-            .type_(Some(type_script))
+            .type_(Some(type_script).pack())
             .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -131,7 +131,7 @@ impl BExtScript {
         };
         packed::Script::new_builder()
             .code_hash(self.data_hash.clone())
-            .hash_type(hash_type)
+            .hash_type(hash_type.into())
             .args(args)
             .build()
     }
@@ -139,7 +139,7 @@ impl BExtScript {
     fn as_type_script(&self, args: packed::Bytes) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(ScriptHashType::Type)
+            .hash_type(ScriptHashType::Type.into())
             .args(args)
             .build()
     }
@@ -220,12 +220,12 @@ impl<'a> CheckVmBExtensionTestRunner<'a> {
                 let mut vec = Vec::with_capacity(8 * 2);
                 vec.extend_from_slice(&num0.to_le_bytes());
                 vec.extend_from_slice(&num1.to_le_bytes());
-                vec.into()
+                vec.pack()
             };
             let script = self.script.as_script(vm_opt, args);
             packed::CellOutput::new_builder()
                 .lock(self.node.always_success_script())
-                .type_(Some(script))
+                .type_(Some(script).pack())
                 .build_exact_capacity(Capacity::shannons(0))
                 .unwrap()
         };
@@ -234,7 +234,7 @@ impl<'a> CheckVmBExtensionTestRunner<'a> {
             .cell_dep(self.script.cell_dep())
             .input(input)
             .output(output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
diff --git a/test/src/specs/hardfork/v2021/vm_version1.rs b/test/src/specs/hardfork/v2021/vm_version1.rs
index e4f935d168..f49d955275 100644
--- a/test/src/specs/hardfork/v2021/vm_version1.rs
+++ b/test/src/specs/hardfork/v2021/vm_version1.rs
@@ -96,12 +96,12 @@ impl NewScript {
         let original_data = node.always_success_raw_data();
         let data = packed::Bytes::new_builder()
             .extend(original_data.as_ref().iter().map(|x| (*x).into()))
-            .push(id)
+            .push(id.into())
             .build();
         let tx = Self::deploy(node, &data, inputs);
         let cell_dep = packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
-            .dep_type(DepType::Code)
+            .dep_type(DepType::Code.into())
             .build();
         let data_hash = packed::CellOutput::calc_data_hash(&data.raw_data());
         let type_hash = tx
@@ -127,7 +127,7 @@ impl NewScript {
         let tx_template = TransactionView::new_advanced_builder();
         let cell_input = inputs.next().unwrap();
         let cell_output = packed::CellOutput::new_builder()
-            .type_(Some(type_script))
+            .type_(Some(type_script).pack())
             .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -153,14 +153,14 @@ impl NewScript {
         };
         packed::Script::new_builder()
             .code_hash(self.data_hash.clone())
-            .hash_type(hash_type)
+            .hash_type(hash_type.into())
             .build()
     }
 
     fn as_type_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(ScriptHashType::Type)
+            .hash_type(ScriptHashType::Type.into())
             .build()
     }
 }
@@ -218,7 +218,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
                 TransactionView::new_advanced_builder().cell_dep(cell_dep),
                 packed::CellOutput::new_builder()
                     .lock(self.node.always_success_script())
-                    .type_(Some(script)),
+                    .type_(Some(script).pack()),
             )
         } else {
             (
@@ -228,12 +228,14 @@ impl<'a> CheckVmVersionTestRunner<'a> {
         };
         let cell_input = inputs.next().unwrap();
         let input_cell = self.get_previous_output(&cell_input);
-        let cell_output = co_builder.capacity(input_cell.capacity.value() - 1).build();
+        let cell_output = co_builder
+            .capacity((input_cell.capacity.value() - 1).pack())
+            .build();
         let tx = tx_builder
             .cell_dep(self.node.always_success_cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
@@ -264,7 +266,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
         .cell_dep(cell_dep)
         .input(input)
         .output(output)
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
@@ -275,7 +277,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
 
     fn get_previous_output(&self, cell_input: &packed::CellInput) -> rpc::CellOutput {
         let previous_output = cell_input.previous_output();
-        let previous_output_index: usize = previous_output.index().into();
+        let previous_output_index: usize = previous_output.index().unpack();
         if let Either::Left(tx) = self
             .node
             .rpc_client()
diff --git a/test/src/specs/hardfork/v2023/vm_version2.rs b/test/src/specs/hardfork/v2023/vm_version2.rs
index aa727f6e89..972fb74f9e 100644
--- a/test/src/specs/hardfork/v2023/vm_version2.rs
+++ b/test/src/specs/hardfork/v2023/vm_version2.rs
@@ -116,12 +116,12 @@ impl NewScript {
         let original_data = node.always_success_raw_data();
         let data = packed::Bytes::new_builder()
             .extend(original_data.as_ref().iter().map(|x| (*x).into()))
-            .push(id)
+            .push(id.into())
             .build();
         let tx = Self::deploy(node, &data, inputs);
         let cell_dep = packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
-            .dep_type(DepType::Code)
+            .dep_type(DepType::Code.into())
             .build();
         let data_hash = packed::CellOutput::calc_data_hash(&data.raw_data());
         let type_hash = tx
@@ -147,7 +147,7 @@ impl NewScript {
         let tx_template = TransactionView::new_advanced_builder();
         let cell_input = inputs.next().unwrap();
         let cell_output = packed::CellOutput::new_builder()
-            .type_(Some(type_script))
+            .type_(Some(type_script).pack())
             .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -174,14 +174,14 @@ impl NewScript {
         };
         packed::Script::new_builder()
             .code_hash(self.data_hash.clone())
-            .hash_type(hash_type)
+            .hash_type(hash_type.into())
             .build()
     }
 
     fn as_type_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(ScriptHashType::Type)
+            .hash_type(ScriptHashType::Type.into())
             .build()
     }
 }
@@ -239,7 +239,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
                 TransactionView::new_advanced_builder().cell_dep(cell_dep),
                 packed::CellOutput::new_builder()
                     .lock(self.node.always_success_script())
-                    .type_(Some(script)),
+                    .type_(Some(script).pack()),
             )
         } else {
             (
@@ -249,12 +249,14 @@ impl<'a> CheckVmVersionTestRunner<'a> {
         };
         let cell_input = inputs.next().unwrap();
         let input_cell = self.get_previous_output(&cell_input);
-        let cell_output = co_builder.capacity(input_cell.capacity.value() - 1).build();
+        let cell_output = co_builder
+            .capacity((input_cell.capacity.value() - 1).pack())
+            .build();
         let tx = tx_builder
             .cell_dep(self.node.always_success_cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
@@ -285,7 +287,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
         .cell_dep(cell_dep)
         .input(input)
         .output(output)
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
@@ -296,7 +298,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
 
     fn get_previous_output(&self, cell_input: &packed::CellInput) -> rpc::CellOutput {
         let previous_output = cell_input.previous_output();
-        let previous_output_index: usize = previous_output.index().into();
+        let previous_output_index: usize = previous_output.index().unpack();
 
         if let Either::Left(tx) = self
             .node
diff --git a/test/src/specs/mining/basic.rs b/test/src/specs/mining/basic.rs
index 930fe933fa..c08357e5b5 100644
--- a/test/src/specs/mining/basic.rs
+++ b/test/src/specs/mining/basic.rs
@@ -3,6 +3,7 @@ use crate::util::cell::gen_spendable;
 use crate::util::transaction::always_success_transaction;
 use crate::{Node, Spec};
 use ckb_jsonrpc_types::BlockTemplate;
+use ckb_types::prelude::*;
 
 pub struct MiningBasic;
 
@@ -49,7 +50,7 @@ impl Spec for BlockTemplates {
                 block1
                     .header()
                     .as_advanced_builder()
-                    .timestamp(block1.header().timestamp() + 1)
+                    .timestamp((block1.header().timestamp() + 1).pack())
                     .build(),
             )
             .build();
@@ -60,13 +61,13 @@ impl Spec for BlockTemplates {
         node.submit_block(&block2);
         assert_eq!(
             block1.hash(),
-            rpc_client.get_tip_header().hash.into(),
+            rpc_client.get_tip_header().hash.pack(),
             "Block1 should be the tip block according first-received policy"
         );
         let template1 = rpc_client.get_block_template(None, None, None);
         assert_eq!(
             block1.hash(),
-            (&template1.parent_hash).into(),
+            template1.parent_hash.pack(),
             "Block1 should be block template's parent block since it's tip block"
         );
 
diff --git a/test/src/specs/mining/bootstrap.rs b/test/src/specs/mining/bootstrap.rs
index d5ae37b989..0bf13bbfcd 100644
--- a/test/src/specs/mining/bootstrap.rs
+++ b/test/src/specs/mining/bootstrap.rs
@@ -20,9 +20,9 @@ impl Spec for BootstrapCellbase {
         node.mine(DEFAULT_TX_PROPOSAL_WINDOW.1 + 1);
 
         let miner = packed::Script::new_builder()
-            .args(Bytes::from(vec![2, 1]))
-            .code_hash(h256!("0xa2"))
-            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(vec![2, 1]).pack())
+            .code_hash(h256!("0xa2").pack())
+            .hash_type(ScriptHashType::Data.into())
             .build();
 
         let is_bootstrap_cellbase = |number| {
diff --git a/test/src/specs/mining/fee.rs b/test/src/specs/mining/fee.rs
index c7bd9be438..abadc4daf8 100644
--- a/test/src/specs/mining/fee.rs
+++ b/test/src/specs/mining/fee.rs
@@ -5,10 +5,14 @@ use crate::util::check::is_transaction_committed;
 use crate::util::transaction::always_success_transaction;
 use crate::{Node, Spec};
 use crate::{DEFAULT_TX_PROPOSAL_WINDOW, FINALIZATION_DELAY_LENGTH};
+use ckb_types::core::TransactionBuilder;
+use ckb_types::packed::CellInput;
+use ckb_types::packed::CellOutput;
+use ckb_types::packed::OutPoint;
+use ckb_types::prelude::*;
 use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionBuilder},
-    packed::{self, CellInput, CellOutput, CellOutputBuilder, OutPoint},
-    prelude::*,
+    core::{capacity_bytes, Capacity},
+    packed::CellOutputBuilder,
 };
 use rand::{thread_rng, Rng};
 
@@ -75,14 +79,14 @@ impl Spec for FeeOfMaxBlockProposalsLimit {
                 let maximal_capacity = cell.capacity().as_u64();
                 let random_capacity = rng.gen_range(minimal_capacity..=maximal_capacity);
                 let output = CellOutput::new_builder()
-                    .capacity(random_capacity)
+                    .capacity(random_capacity.pack())
                     .lock(cell.cell_output.lock())
                     .type_(cell.cell_output.type_())
                     .build();
                 TransactionBuilder::default()
                     .input(as_input(&cell))
                     .output(output)
-                    .output_data(packed::Bytes::default())
+                    .output_data(Default::default())
                     .cell_dep(node.always_success_cell_dep())
                     .build()
             })
@@ -131,14 +135,14 @@ impl Spec for FeeOfMultipleMaxBlockProposalsLimit {
                 let maximal_capacity = cell.capacity().as_u64();
                 let random_capacity = rng.gen_range(minimal_capacity..=maximal_capacity);
                 let output = CellOutput::new_builder()
-                    .capacity(random_capacity)
+                    .capacity(random_capacity.pack())
                     .lock(cell.cell_output.lock())
                     .type_(cell.cell_output.type_())
                     .build();
                 TransactionBuilder::default()
                     .input(as_input(&cell))
                     .output(output)
-                    .output_data(packed::Bytes::default())
+                    .output_data(Default::default())
                     .cell_dep(node.always_success_cell_dep())
                     .build()
             })
@@ -221,7 +225,7 @@ impl Spec for ProposeDuplicated {
             let uncle = node
                 .new_block_builder(None, None, None)
                 .proposal(tx.proposal_short_id())
-                .nonce(99999)
+                .nonce(99999.pack())
                 .build()
                 .as_uncle();
             node.mine(1);
@@ -252,7 +256,7 @@ impl Spec for MalformedTx {
         let tx0 = node0.new_transaction_spend_tip_cellbase();
 
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(1000))
+            .capacity(capacity_bytes!(1000).pack())
             .build();
 
         let child = tx0
diff --git a/test/src/specs/mining/proposal.rs b/test/src/specs/mining/proposal.rs
index eb4abe8a2c..272252671c 100644
--- a/test/src/specs/mining/proposal.rs
+++ b/test/src/specs/mining/proposal.rs
@@ -2,6 +2,7 @@ use crate::generic::GetProposalTxIds;
 use crate::util::cell::gen_spendable;
 use crate::util::transaction::always_success_transaction;
 use crate::{Node, Spec};
+use ckb_types::prelude::*;
 
 pub struct AvoidDuplicatedProposalsWithUncles;
 
@@ -20,7 +21,7 @@ impl Spec for AvoidDuplicatedProposalsWithUncles {
             let block = node.new_block(None, None, None);
             let uncle = block
                 .as_advanced_builder()
-                .timestamp(block.timestamp() + 1)
+                .timestamp((block.timestamp() + 1).pack())
                 .set_proposals(vec![tx.proposal_short_id()])
                 .build();
             node.submit_block(&block);
diff --git a/test/src/specs/mining/uncle.rs b/test/src/specs/mining/uncle.rs
index 6d51311d08..04d044421f 100644
--- a/test/src/specs/mining/uncle.rs
+++ b/test/src/specs/mining/uncle.rs
@@ -1,5 +1,6 @@
 use crate::{Node, Spec};
 use ckb_types::core::{BlockView, EpochNumberWithFraction};
+use ckb_types::prelude::*;
 
 // Convention:
 //   main-block: a block on the main fork
@@ -85,16 +86,19 @@ impl Spec for UncleInheritFromForkUncle {
 
         let uncle_child = uncle_parent
             .as_advanced_builder()
-            .number(uncle_parent.number() + 1)
+            .number((uncle_parent.number() + 1).pack())
             .parent_hash(uncle_parent.hash())
-            .timestamp(uncle_parent.timestamp() + 1)
-            .epoch({
-                let parent_epoch = uncle_parent.epoch();
-                let epoch_number = parent_epoch.number();
-                let epoch_index = parent_epoch.index();
-                let epoch_length = parent_epoch.length();
-                EpochNumberWithFraction::new(epoch_number, epoch_index + 1, epoch_length)
-            })
+            .timestamp((uncle_parent.timestamp() + 1).pack())
+            .epoch(
+                {
+                    let parent_epoch = uncle_parent.epoch();
+                    let epoch_number = parent_epoch.number();
+                    let epoch_index = parent_epoch.index();
+                    let epoch_length = parent_epoch.length();
+                    EpochNumberWithFraction::new(epoch_number, epoch_index + 1, epoch_length)
+                }
+                .pack(),
+            )
             .build();
 
         let longer_fork = (0..=target_node.get_tip_block_number()).map(|_| {
diff --git a/test/src/specs/relay/block_relay.rs b/test/src/specs/relay/block_relay.rs
index a3d054b98e..22569ce61e 100644
--- a/test/src/specs/relay/block_relay.rs
+++ b/test/src/specs/relay/block_relay.rs
@@ -3,6 +3,7 @@ use crate::util::mining::out_ibd_mode;
 use crate::utils::{now_ms, sleep, wait_until};
 use crate::{Node, Spec};
 use ckb_logger::info;
+use ckb_types::prelude::*;
 use std::time::Duration;
 
 pub struct RelayTooNewBlock;
@@ -21,7 +22,7 @@ impl Spec for RelayTooNewBlock {
         let future = Duration::from_secs(6_000).as_millis() as u64;
         let too_new_block = node0
             .new_block_builder(None, None, None)
-            .timestamp(now_ms() + future)
+            .timestamp((now_ms() + future).pack())
             .build();
 
         let _too_new_hash = node0.process_block_without_verify(&too_new_block, true);
diff --git a/test/src/specs/relay/compact_block.rs b/test/src/specs/relay/compact_block.rs
index 0cd024796c..9b8c078b7f 100644
--- a/test/src/specs/relay/compact_block.rs
+++ b/test/src/specs/relay/compact_block.rs
@@ -40,7 +40,7 @@ impl Spec for CompactBlockEmptyParentUnknown {
             .new_block_builder(None, None, None)
             .header(
                 HeaderBuilder::default()
-                    .parent_hash(h256!("0x123456"))
+                    .parent_hash(h256!("0x123456").pack())
                     .build(),
             )
             .build();
@@ -297,7 +297,7 @@ impl Spec for CompactBlockMissingWithDropTx {
                             .as_reader()
                             .indexes()
                             .iter()
-                            .map(Into::<u32>::into)
+                            .map(|i| Unpack::<u32>::unpack(&i))
                             .collect::<Vec<u32>>();
                         vec![2] == msg
                     } else {
@@ -316,7 +316,7 @@ impl Spec for CompactBlockMissingWithDropTx {
 
         let content = packed::BlockTransactions::new_builder()
             .block_hash(new_block.hash())
-            .transactions(vec![new_tx_2.data()])
+            .transactions(vec![new_tx_2.data()].pack())
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
 
@@ -331,7 +331,7 @@ impl Spec for CompactBlockMissingWithDropTx {
                             .as_reader()
                             .indexes()
                             .iter()
-                            .map(Into::<u32>::into)
+                            .map(|i| Unpack::<u32>::unpack(&i))
                             .collect::<Vec<u32>>();
                         vec![1, 2] == msg
                     } else {
@@ -348,7 +348,7 @@ impl Spec for CompactBlockMissingWithDropTx {
 
         let content = packed::BlockTransactions::new_builder()
             .block_hash(new_block.hash())
-            .transactions(vec![new_tx_1.data(), new_tx_2.data()])
+            .transactions(vec![new_tx_1.data(), new_tx_2.data()].pack())
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/test/src/specs/relay/get_block_proposal_process.rs b/test/src/specs/relay/get_block_proposal_process.rs
index 9f7083180f..f3e59b45e1 100644
--- a/test/src/specs/relay/get_block_proposal_process.rs
+++ b/test/src/specs/relay/get_block_proposal_process.rs
@@ -46,7 +46,7 @@ impl Spec for ProposalRespondSizelimit {
 
         let content = packed::GetBlockProposal::new_builder()
             .block_hash(tip_hash)
-            .proposals(proposal_ids)
+            .proposals(proposal_ids.pack())
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/test/src/specs/relay/get_block_transactions_process.rs b/test/src/specs/relay/get_block_transactions_process.rs
index b40b22b2da..e621ad336d 100644
--- a/test/src/specs/relay/get_block_transactions_process.rs
+++ b/test/src/specs/relay/get_block_transactions_process.rs
@@ -24,18 +24,21 @@ impl Spec for MissingUncleRequest {
         node.mine(1);
 
         let builder = node.new_block_builder(None, None, None);
-        let block1 = builder.clone().nonce(0).build();
-        let block2 = builder.nonce(1).build();
+        let block1 = builder.clone().nonce(0.pack()).build();
+        let block2 = builder.nonce(1.pack()).build();
         node.submit_block(&block1);
         node.submit_block(&block2);
 
         let builder = node.new_block_builder(None, None, None);
-        let block = builder.set_uncles(vec![block2.as_uncle()]).nonce(0).build();
+        let block = builder
+            .set_uncles(vec![block2.as_uncle()])
+            .nonce(0.pack())
+            .build();
         node.submit_block(&block);
 
         let content = packed::GetBlockTransactions::new_builder()
             .block_hash(block.hash())
-            .uncle_indexes([0u32])
+            .uncle_indexes([0u32].pack())
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/test/src/specs/relay/transaction_relay.rs b/test/src/specs/relay/transaction_relay.rs
index 28cd66a3fe..1a9512314c 100644
--- a/test/src/specs/relay/transaction_relay.rs
+++ b/test/src/specs/relay/transaction_relay.rs
@@ -241,7 +241,7 @@ impl Spec for TransactionRelayConflict {
         let tx1 = node0.new_transaction(tx_hash_0.clone());
         let tx2_temp = node0.new_transaction(tx_hash_0);
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(80))
+            .capacity(capacity_bytes!(80).pack())
             .build();
 
         let tx2 = tx2_temp
diff --git a/test/src/specs/relay/transaction_relay_low_fee_rate.rs b/test/src/specs/relay/transaction_relay_low_fee_rate.rs
index f172f4b569..1aad334416 100644
--- a/test/src/specs/relay/transaction_relay_low_fee_rate.rs
+++ b/test/src/specs/relay/transaction_relay_low_fee_rate.rs
@@ -5,10 +5,7 @@ use crate::util::log_monitor::monitor_log_until_expected_show;
 use crate::util::mining::out_ibd_mode;
 use crate::{Node, Spec};
 use ckb_logger::debug;
-use ckb_types::{
-    core::{FeeRate, TransactionBuilder},
-    packed,
-};
+use ckb_types::core::{FeeRate, TransactionBuilder};
 
 pub struct TransactionRelayLowFeeRate;
 
@@ -26,7 +23,7 @@ impl Spec for TransactionRelayLowFeeRate {
         let low_fee = TransactionBuilder::default()
             .input(as_input(&cells[0]))
             .output(as_output(&cells[0]))
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .cell_dep(node0.always_success_cell_dep())
             .build();
 
diff --git a/test/src/specs/rpc/get_block_template.rs b/test/src/specs/rpc/get_block_template.rs
index 46c509b44d..58a076e117 100644
--- a/test/src/specs/rpc/get_block_template.rs
+++ b/test/src/specs/rpc/get_block_template.rs
@@ -1,6 +1,6 @@
 use crate::{Node, Spec};
 use ckb_jsonrpc_types::AsEpochNumberWithFraction;
-use ckb_types::packed;
+use ckb_types::prelude::*;
 
 pub struct RpcGetBlockTemplate;
 
@@ -48,10 +48,10 @@ impl Spec for RpcGetBlockTemplate {
         let parent_block_hash = node0.get_tip_block().hash();
         assert_eq!(
             parent_block_hash,
-            (&genesis_block_template.parent_hash).into(),
+            genesis_block_template.parent_hash.pack(),
             "Parent block hash should be {}, but got {}",
             parent_block_hash,
-            Into::<packed::Byte32>::into(&genesis_block_template.parent_hash)
+            genesis_block_template.parent_hash.pack()
         );
         assert_eq!(
             0,
diff --git a/test/src/specs/rpc/submit_block.rs b/test/src/specs/rpc/submit_block.rs
index 7e1bb10470..6a06fa8025 100644
--- a/test/src/specs/rpc/submit_block.rs
+++ b/test/src/specs/rpc/submit_block.rs
@@ -1,6 +1,9 @@
 use crate::utils::now_ms;
 use crate::{Node, Spec};
-use ckb_types::core::{EpochNumberWithFraction, HeaderView};
+use ckb_types::{
+    core::{EpochNumberWithFraction, HeaderView},
+    prelude::*,
+};
 
 pub struct RpcSubmitBlock;
 
@@ -14,7 +17,10 @@ impl Spec for RpcSubmitBlock {
         node1.mine_until_out_bootstrap_period();
 
         // build block with wrong block number
-        let block = node0.new_block_builder(None, None, None).number(2).build();
+        let block = node0
+            .new_block_builder(None, None, None)
+            .number(2.pack())
+            .build();
         let block_err = node0
             .rpc_client()
             .submit_block("".to_owned(), block.data().into())
@@ -35,7 +41,7 @@ impl Spec for RpcSubmitBlock {
         let epoch = EpochNumberWithFraction::new(tip_epoch.number() + 1, 0, 100);
         let block = node0
             .new_block_builder(None, None, None)
-            .epoch(epoch)
+            .epoch(epoch.pack())
             .build();
         let block_err = node0
             .rpc_client()
@@ -81,7 +87,7 @@ impl Spec for RpcSubmitBlock {
         // so here plus another 15s to make sure when submit the block it still out of the limit
         let block = node0
             .new_block_builder(None, None, None)
-            .timestamp(now_ms() + 30_000)
+            .timestamp((now_ms() + 30_000).pack())
             .build();
         let block_err = node0
             .rpc_client()
@@ -96,7 +102,7 @@ impl Spec for RpcSubmitBlock {
         let median_time = node0.rpc_client().get_blockchain_info().median_time.value();
         let block = node0
             .new_block_builder(None, None, None)
-            .timestamp(median_time - 1)
+            .timestamp((median_time - 1).pack())
             .build();
         let block_err = node0
             .rpc_client()
diff --git a/test/src/specs/rpc/transaction_proof.rs b/test/src/specs/rpc/transaction_proof.rs
index d4eefcb4c4..0b5d83384e 100644
--- a/test/src/specs/rpc/transaction_proof.rs
+++ b/test/src/specs/rpc/transaction_proof.rs
@@ -1,4 +1,5 @@
 use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
+use ckb_types::prelude::*;
 
 pub struct RpcTransactionProof;
 
@@ -9,7 +10,7 @@ impl Spec for RpcTransactionProof {
 
         let tx_hash = node0.generate_transaction();
         node0.mine_until_transaction_confirm(&tx_hash);
-        let tx_hashes = vec![tx_hash.into()];
+        let tx_hashes = vec![tx_hash.unpack()];
         let proof = node0
             .rpc_client()
             .inner()
diff --git a/test/src/specs/sync/block_filter.rs b/test/src/specs/sync/block_filter.rs
index 0c86a1cb57..0996da7935 100644
--- a/test/src/specs/sync/block_filter.rs
+++ b/test/src/specs/sync/block_filter.rs
@@ -31,7 +31,7 @@ impl Spec for GetBlockFilterCheckPoints {
         let start_number: u64 = 0;
         let request = {
             let content = packed::GetBlockFilterCheckPoints::new_builder()
-                .start_number(start_number)
+                .start_number(start_number.pack())
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -45,7 +45,7 @@ impl Spec for GetBlockFilterCheckPoints {
         match packed::BlockFilterMessageReader::from_slice(&data) {
             Ok(msg) => match msg.to_enum() {
                 packed::BlockFilterMessageUnionReader::BlockFilterCheckPoints(reader) => {
-                    let resp_start_number: u64 = reader.start_number().into();
+                    let resp_start_number: u64 = reader.start_number().unpack();
                     assert_eq!(start_number, resp_start_number);
                     info!("start_number matched");
 
@@ -113,7 +113,7 @@ impl Spec for GetBlockFilterHashes {
         let start_number: u64 = 2;
         let request = {
             let content = packed::GetBlockFilterHashes::new_builder()
-                .start_number(start_number)
+                .start_number(start_number.pack())
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -127,7 +127,7 @@ impl Spec for GetBlockFilterHashes {
         match packed::BlockFilterMessageReader::from_slice(&data) {
             Ok(msg) => match msg.to_enum() {
                 packed::BlockFilterMessageUnionReader::BlockFilterHashes(reader) => {
-                    let resp_start_number: u64 = reader.start_number().into();
+                    let resp_start_number: u64 = reader.start_number().unpack();
                     assert_eq!(start_number, resp_start_number);
                     info!("start_number matched");
 
@@ -205,7 +205,7 @@ impl Spec for GetBlockFilters {
         let start_number: u64 = 42;
         let request = {
             let content = packed::GetBlockFilters::new_builder()
-                .start_number(start_number)
+                .start_number(start_number.pack())
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -219,7 +219,7 @@ impl Spec for GetBlockFilters {
         match packed::BlockFilterMessageReader::from_slice(&data) {
             Ok(msg) => match msg.to_enum() {
                 packed::BlockFilterMessageUnionReader::BlockFilters(reader) => {
-                    let resp_start_number: u64 = reader.start_number().into();
+                    let resp_start_number: u64 = reader.start_number().unpack();
                     assert_eq!(start_number, resp_start_number);
                     info!("start_number matched");
 
@@ -231,7 +231,7 @@ impl Spec for GetBlockFilters {
                     let filters: Vec<Bytes> = reader
                         .filters()
                         .iter()
-                        .map(|item| item.to_entity().into())
+                        .map(|item| item.to_entity().unpack())
                         .collect();
 
                     assert_eq!(
@@ -289,7 +289,7 @@ impl Spec for GetBlockFiltersNotReachBatch {
         info!("start_number: {start_number}");
         let request = {
             let content = packed::GetBlockFilters::new_builder()
-                .start_number(start_number)
+                .start_number(start_number.pack())
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -303,7 +303,7 @@ impl Spec for GetBlockFiltersNotReachBatch {
         match packed::BlockFilterMessageReader::from_slice(&data) {
             Ok(msg) => match msg.to_enum() {
                 packed::BlockFilterMessageUnionReader::BlockFilters(reader) => {
-                    let resp_start_number: u64 = reader.start_number().into();
+                    let resp_start_number: u64 = reader.start_number().unpack();
                     assert_eq!(start_number, resp_start_number);
                     info!("start_number matched");
 
@@ -315,7 +315,7 @@ impl Spec for GetBlockFiltersNotReachBatch {
                     let filters: Vec<Bytes> = reader
                         .filters()
                         .iter()
-                        .map(|item| item.to_entity().into())
+                        .map(|item| item.to_entity().unpack())
                         .collect();
 
                     assert_eq!(
diff --git a/test/src/specs/sync/block_sync.rs b/test/src/specs/sync/block_sync.rs
index d283150a57..10f2ef9ffe 100644
--- a/test/src/specs/sync/block_sync.rs
+++ b/test/src/specs/sync/block_sync.rs
@@ -57,8 +57,8 @@ impl Spec for BlockSyncWithUncle {
         let node1 = &nodes[1];
 
         let new_builder = node1.new_block_builder(None, None, None);
-        let new_block1 = new_builder.clone().nonce(0).build();
-        let new_block2 = new_builder.nonce(1).build();
+        let new_block1 = new_builder.clone().nonce(0.pack()).build();
+        let new_block2 = new_builder.nonce(1.pack()).build();
 
         node1.submit_block(&new_block1);
         node1.submit_block(&new_block2);
@@ -329,7 +329,7 @@ impl Spec for BlockSyncNonAncestorBestBlocks {
         let b = a
             .data()
             .as_advanced_builder()
-            .timestamp(a.timestamp() + 1)
+            .timestamp((a.timestamp() + 1).pack())
             .build();
         assert_ne!(a.hash(), b.hash());
         node1.submit_block(&b);
@@ -432,7 +432,7 @@ impl Spec for SyncTooNewBlock {
         for _ in 0..3 {
             let too_new_block = node0
                 .new_block_builder(None, None, None)
-                .timestamp(now_ms() + future)
+                .timestamp((now_ms() + future).pack())
                 .build();
 
             // node1 sync node1 with too new block
@@ -471,7 +471,9 @@ impl Spec for HeaderSyncCycle {
         let mut net = Net::new(self.name(), node0.consensus(), vec![SupportProtocols::Sync]);
         net.connect(node0);
 
-        let send_headers = SendHeaders::new_builder().headers(Vec::new()).build();
+        let send_headers = SendHeaders::new_builder()
+            .headers(Vec::new().pack())
+            .build();
 
         let msg = SyncMessage::new_builder()
             .set(send_headers)
diff --git a/test/src/specs/sync/chain_forks.rs b/test/src/specs/sync/chain_forks.rs
index 446de599be..b1d9132f6c 100644
--- a/test/src/specs/sync/chain_forks.rs
+++ b/test/src/specs/sync/chain_forks.rs
@@ -144,10 +144,10 @@ impl Spec for ChainFork3 {
                 .get(0)
                 .unwrap()
                 .to_entity();
-            let old_capacity: Capacity = old_output.capacity().into();
+            let old_capacity: Capacity = old_output.capacity().unpack();
             let new_output = old_output
                 .as_builder()
-                .capacity(old_capacity.safe_add(capacity_bytes!(1)).unwrap())
+                .capacity(old_capacity.safe_add(capacity_bytes!(1)).unwrap().pack())
                 .build();
             transaction
                 .as_advanced_builder()
@@ -214,7 +214,7 @@ impl Spec for ChainFork4 {
                 .unwrap()
                 .to_entity()
                 .as_builder()
-                .capacity(capacity_bytes!(1))
+                .capacity(capacity_bytes!(1).pack())
                 .build();
             transaction
                 .as_advanced_builder()
@@ -344,7 +344,7 @@ impl Spec for ChainFork6 {
         node1.mine(2);
         info!("Generate 1 block (F) with spending non-existent transaction on node1");
         let block = node1.new_block(None, None, None);
-        let invalid_transaction = node1.new_transaction(h256!("0x1").into());
+        let invalid_transaction = node1.new_transaction(h256!("0x1").pack());
         let invalid_block = block
             .as_advanced_builder()
             .transaction(invalid_transaction)
@@ -402,7 +402,11 @@ impl Spec for ChainFork7 {
         let block = node1.new_block(None, None, None);
         let transaction = node1.new_transaction_spend_tip_cellbase();
         let input = transaction.inputs().as_reader().get(0).unwrap().to_entity();
-        let previous_output = input.previous_output().as_builder().index(999u32).build();
+        let previous_output = input
+            .previous_output()
+            .as_builder()
+            .index(999u32.pack())
+            .build();
         let input = input.as_builder().previous_output(previous_output).build();
         let invalid_transaction = transaction
             .as_advanced_builder()
@@ -572,7 +576,7 @@ impl Spec for ForksContainSameUncle {
         let block_b = node_b
             .new_block_builder(None, None, None)
             .set_uncles(vec![uncle.as_uncle()])
-            .timestamp(block_a.timestamp() + 2)
+            .timestamp((block_a.timestamp() + 2).pack())
             .build();
         node_a.submit_block(&block_a);
         node_b.submit_block(&block_b);
diff --git a/test/src/specs/sync/invalid_locator_size.rs b/test/src/specs/sync/invalid_locator_size.rs
index ed7091959c..e11262ca30 100644
--- a/test/src/specs/sync/invalid_locator_size.rs
+++ b/test/src/specs/sync/invalid_locator_size.rs
@@ -21,13 +21,13 @@ impl Spec for InvalidLocatorSize {
         net.connect(node0);
 
         let hashes: Vec<Byte32> = (0..=MAX_LOCATOR_SIZE)
-            .map(|_| h256!("0x1").into())
+            .map(|_| h256!("0x1").pack())
             .collect();
 
         let message = SyncMessage::new_builder()
             .set(
                 GetHeaders::new_builder()
-                    .block_locator_hashes(hashes)
+                    .block_locator_hashes(hashes.pack())
                     .build(),
             )
             .build()
diff --git a/test/src/specs/tx_pool/collision.rs b/test/src/specs/tx_pool/collision.rs
index 0f05d7f580..0d93697c03 100644
--- a/test/src/specs/tx_pool/collision.rs
+++ b/test/src/specs/tx_pool/collision.rs
@@ -4,11 +4,8 @@ use crate::util::check::{
 use crate::utils::{assert_send_transaction_fail, blank, commit, propose};
 use crate::{Node, Spec};
 use ckb_types::bytes::Bytes;
+use ckb_types::core::{capacity_bytes, Capacity, TransactionView};
 use ckb_types::prelude::*;
-use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionView},
-    packed,
-};
 
 // Convention:
 //   * `tx1` and `tx2` are cousin transactions, with the same transaction content, except the
@@ -197,7 +194,7 @@ fn conflict_transactions_with_capacity(
         .unwrap();
     let txb = txa
         .as_advanced_builder()
-        .set_outputs_data(vec![output_data.into()])
+        .set_outputs_data(vec![output_data.pack()])
         .set_outputs(vec![output])
         .build();
     assert_ne!(txa.hash(), txb.hash());
@@ -216,7 +213,7 @@ fn cousin_txs_with_same_hash_different_witness_hash(
     let tx1 = node.new_transaction_spend_tip_cellbase();
     let tx2 = tx1
         .as_advanced_builder()
-        .witness(packed::Bytes::default())
+        .witness(Default::default())
         .build();
     assert_eq!(tx1.hash(), tx2.hash());
     assert_eq!(tx1.proposal_short_id(), tx2.proposal_short_id());
diff --git a/test/src/specs/tx_pool/dead_cell_deps.rs b/test/src/specs/tx_pool/dead_cell_deps.rs
index 77ae8fb619..0b7816bf84 100644
--- a/test/src/specs/tx_pool/dead_cell_deps.rs
+++ b/test/src/specs/tx_pool/dead_cell_deps.rs
@@ -50,7 +50,7 @@ impl Spec for CellBeingCellDepThenSpentInSameBlockTestSubmitBlock {
         let tx_c = {
             let tx = always_success_transaction(node0, input_c);
             let cell_dep_to_tx_a = CellDepBuilder::default()
-                .dep_type(DepType::Code)
+                .dep_type(DepType::Code.into())
                 .out_point(OutPoint::new(tx_a.hash(), 0))
                 .build();
             tx.as_advanced_builder().cell_dep(cell_dep_to_tx_a).build()
@@ -122,7 +122,7 @@ impl Spec for CellBeingSpentThenCellDepInSameBlockTestSubmitBlock {
         let tx_c = {
             let tx = always_success_transaction(node0, input_c);
             let cell_dep_to_tx_a = CellDepBuilder::default()
-                .dep_type(DepType::Code)
+                .dep_type(DepType::Code.into())
                 .out_point(OutPoint::new(tx_a.hash(), 0))
                 .build();
             tx.as_advanced_builder().cell_dep(cell_dep_to_tx_a).build()
@@ -208,7 +208,7 @@ impl Spec for CellBeingCellDepAndSpentInSameBlockTestGetBlockTemplate {
         let mut tx_c = {
             let tx = always_success_transaction(node0, input_c);
             let cell_dep_to_tx_a = CellDepBuilder::default()
-                .dep_type(DepType::Code)
+                .dep_type(DepType::Code.into())
                 .out_point(OutPoint::new(tx_a.hash(), 0))
                 .build();
             tx.as_advanced_builder().cell_dep(cell_dep_to_tx_a).build()
diff --git a/test/src/specs/tx_pool/different_txs_with_same_input.rs b/test/src/specs/tx_pool/different_txs_with_same_input.rs
index cdd1abf8dd..f590f7ae81 100644
--- a/test/src/specs/tx_pool/different_txs_with_same_input.rs
+++ b/test/src/specs/tx_pool/different_txs_with_same_input.rs
@@ -22,7 +22,7 @@ impl Spec for DifferentTxsWithSameInputWithOutRBF {
 
         // Set tx2 fee to a higher value, tx1 capacity is 100, set tx2 capacity to 80 for +20 fee.
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(80))
+            .capacity(capacity_bytes!(80).pack())
             .build();
 
         let tx2 = tx2_temp
diff --git a/test/src/specs/tx_pool/limit.rs b/test/src/specs/tx_pool/limit.rs
index 60e2090ba2..ba9a84df80 100644
--- a/test/src/specs/tx_pool/limit.rs
+++ b/test/src/specs/tx_pool/limit.rs
@@ -83,7 +83,7 @@ impl Spec for TxPoolLimitAncestorCount {
         };
 
         let cell_dep = CellDepBuilder::default()
-            .dep_type(DepType::Code)
+            .dep_type(DepType::Code.into())
             .out_point(OutPoint::new(tx_a.hash(), 0))
             .build();
 
diff --git a/test/src/specs/tx_pool/mod.rs b/test/src/specs/tx_pool/mod.rs
index b8e1abc45c..436fc44b93 100644
--- a/test/src/specs/tx_pool/mod.rs
+++ b/test/src/specs/tx_pool/mod.rs
@@ -55,12 +55,12 @@ use ckb_app_config::BlockAssemblerConfig;
 use ckb_chain_spec::{build_genesis_type_id_script, OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL};
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_resource::CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL;
-use ckb_types::{bytes::Bytes, core::ScriptHashType, H256};
+use ckb_types::{bytes::Bytes, core::ScriptHashType, prelude::*, H256};
 
 fn type_lock_script_code_hash() -> H256 {
     build_genesis_type_id_script(OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL)
         .calc_script_hash()
-        .into()
+        .unpack()
 }
 
 fn new_block_assembler_config(lock_arg: Bytes, hash_type: ScriptHashType) -> BlockAssemblerConfig {
diff --git a/test/src/specs/tx_pool/orphan_tx.rs b/test/src/specs/tx_pool/orphan_tx.rs
index ac7605dc40..7e056380d5 100644
--- a/test/src/specs/tx_pool/orphan_tx.rs
+++ b/test/src/specs/tx_pool/orphan_tx.rs
@@ -136,7 +136,7 @@ fn build_tx_chain(
 
     let script = node0.always_success_script();
     let new_output1 = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(200))
+        .capacity(capacity_bytes!(200).pack())
         .lock(script.clone())
         .build();
     let new_output2 = new_output1.clone();
@@ -158,7 +158,7 @@ fn build_tx_chain(
 
     let cell_dep = node0.always_success_cell_dep();
     let final_output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(80))
+        .capacity(capacity_bytes!(80).pack())
         .lock(script)
         .build();
     let final_tx = TransactionBuilder::default()
@@ -373,7 +373,7 @@ impl Spec for TxPoolOrphanDoubleSpend {
 
         let script = node0.always_success_script();
         let new_output1 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(200))
+            .capacity(capacity_bytes!(200).pack())
             .lock(script)
             .build();
         let new_output2 = new_output1.clone();
diff --git a/test/src/specs/tx_pool/pool_reconcile.rs b/test/src/specs/tx_pool/pool_reconcile.rs
index 6377216689..280c506cc8 100644
--- a/test/src/specs/tx_pool/pool_reconcile.rs
+++ b/test/src/specs/tx_pool/pool_reconcile.rs
@@ -112,7 +112,7 @@ impl Spec for PoolResolveConflictAfterReorg {
                 !(template
                     .transactions
                     .iter()
-                    .any(|tx| tx.hash == tx1.hash().into()))
+                    .any(|tx| tx.hash == tx1.hash().unpack()))
             })
             .set_proposals(txs.iter().map(|tx| tx.proposal_short_id()).collect())
             .build();
@@ -161,7 +161,7 @@ impl Spec for PoolResolveConflictAfterReorg {
                     .build()
             }])
             .set_outputs(vec![CellOutputBuilder::default()
-                .capacity(capacity_bytes!(99))
+                .capacity(capacity_bytes!(99).pack())
                 .build()])
             .build();
 
diff --git a/test/src/specs/tx_pool/replace.rs b/test/src/specs/tx_pool/replace.rs
index dad1b5107f..b6ef175906 100644
--- a/test/src/specs/tx_pool/replace.rs
+++ b/test/src/specs/tx_pool/replace.rs
@@ -28,7 +28,7 @@ impl Spec for RbfEnable {
         let tx1 = node0.new_transaction(tx_hash_0);
 
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let tx1 = tx1.as_advanced_builder().set_outputs(vec![output]).build();
@@ -59,7 +59,7 @@ impl Spec for RbfBasic {
         let tx1 = node0.new_transaction(tx_hash_0.clone());
         let tx2_temp = node0.new_transaction(tx_hash_0);
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(99))
+            .capacity(capacity_bytes!(99).pack())
             .build();
 
         let tx1 = tx1.as_advanced_builder().set_outputs(vec![output]).build();
@@ -76,7 +76,7 @@ impl Spec for RbfBasic {
 
         // Set tx2 fee to a higher value, tx1 capacity is 99, set tx2 capacity to 95 for +4 fee.
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(95))
+            .capacity(capacity_bytes!(95).pack())
             .build();
 
         let tx2 = tx2_temp
@@ -88,7 +88,7 @@ impl Spec for RbfBasic {
             .rpc_client()
             .send_transaction_result(tx2.data().into());
         assert!(res.is_ok(), "tx2 should replace with old tx");
-        assert_eq!(get_tx_pool_conflicts(node0), vec![tx1.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx1.hash().unpack()]);
 
         let ret = node0
             .rpc_client()
@@ -141,7 +141,7 @@ impl Spec for RbfBasic {
         assert!(ret.transaction.is_none());
         assert!(matches!(ret.tx_status.status, Status::Rejected));
         assert!(ret.tx_status.reason.unwrap().contains("RBFRejected"));
-        assert_eq!(get_tx_pool_conflicts(node0), vec![tx1.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx1.hash().unpack()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -230,14 +230,14 @@ impl Spec for RbfSameInputwithLessFee {
         let tx2_temp = node0.new_transaction(tx_hash_0);
 
         let output1 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(80))
+            .capacity(capacity_bytes!(80).pack())
             .build();
 
         let tx1 = tx1.as_advanced_builder().set_outputs(vec![output1]).build();
 
         // Set tx2 fee to a lower value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(90))
+            .capacity(capacity_bytes!(90).pack())
             .build();
 
         let tx2 = tx2_temp
@@ -256,7 +256,7 @@ impl Spec for RbfSameInputwithLessFee {
         ));
 
         // local submit tx RBF check failed, will be added into conflicts pool
-        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -300,7 +300,7 @@ impl Spec for RbfTooManyDescendants {
 
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let tx2 = tx0_temp
@@ -319,7 +319,7 @@ impl Spec for RbfTooManyDescendants {
             .contains("Tx conflict with too many txs"));
 
         // local submit tx RBF check failed, will not in conflicts pool
-        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -363,7 +363,7 @@ impl Spec for RbfContainNewTx {
         let clone_tx = txs[2].clone();
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let tx2 = clone_tx
@@ -394,7 +394,7 @@ impl Spec for RbfContainNewTx {
             .contains("new Tx contains unconfirmed inputs"));
 
         // local submit tx RBF check failed, will be in conflicts pool
-        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -438,7 +438,7 @@ impl Spec for RbfContainInvalidInput {
         let clone_tx = txs[2].clone();
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let tx2 = clone_tx
@@ -469,7 +469,7 @@ impl Spec for RbfContainInvalidInput {
             .contains("new Tx contains inputs in descendants of to be replaced Tx"));
 
         // local submit tx RBF check failed, will not in conflicts pool
-        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().unpack()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -492,7 +492,7 @@ impl Spec for RbfChildPayForParent {
         let max_count = 5;
 
         let output5 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(50))
+            .capacity(capacity_bytes!(50).pack())
             .build();
 
         while txs.len() <= max_count {
@@ -524,7 +524,7 @@ impl Spec for RbfChildPayForParent {
         let clone_tx = txs[2].clone();
         // Set tx2 fee to a higher value, but not enough to pay for tx4
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let new_tx = clone_tx
@@ -548,11 +548,11 @@ impl Spec for RbfChildPayForParent {
             .contains("RBF rejected: Tx's current fee is 3000000000, expect it to >= 5000000363 to replace old txs"));
 
         // local submit tx RBF check failed, will be in conflicts pool
-        assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().unpack()]);
 
         // let's try a new transaction with new higher fee
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(45))
+            .capacity(capacity_bytes!(45).pack())
             .build();
         let new_tx_ok = clone_tx
             .as_advanced_builder()
@@ -572,9 +572,9 @@ impl Spec for RbfChildPayForParent {
         // tx2 tx3 tx4 is replaced
         let mut expected: Vec<ckb_types::H256> = txs[2..=max_count - 1]
             .iter()
-            .map(|tx| tx.hash().into())
+            .map(|tx| tx.hash().unpack())
             .collect::<Vec<_>>();
-        expected.push(new_tx.hash().into());
+        expected.push(new_tx.hash().unpack());
         expected.sort_unstable();
         let conflicts = get_tx_pool_conflicts(node0);
         assert_eq!(conflicts, expected);
@@ -609,7 +609,7 @@ impl Spec for RbfContainInvalidCells {
 
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
         let tx2 = clone_tx
             .as_advanced_builder()
@@ -688,7 +688,7 @@ impl Spec for RbfRejectReplaceProposed {
         let clone_tx = txs[2].clone();
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let tx1_hash = txs[2].hash();
@@ -798,7 +798,7 @@ impl Spec for RbfReplaceProposedSuccess {
         let clone_tx = txs[2].clone();
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70))
+            .capacity(capacity_bytes!(70).pack())
             .build();
 
         let tx1_hash = txs[2].hash();
@@ -843,9 +843,9 @@ impl Spec for RbfReplaceProposedSuccess {
         assert_eq!(tx1_status.status, Status::Rejected);
 
         let mut expected = [
-            txs[2].hash().into(),
-            txs[3].hash().into(),
-            txs[4].hash().into(),
+            txs[2].hash().unpack(),
+            txs[3].hash().unpack(),
+            txs[4].hash().unpack(),
         ];
         expected.sort_unstable();
         assert_eq!(get_tx_pool_conflicts(node0), expected);
@@ -893,7 +893,7 @@ impl Spec for RbfConcurrency {
         ];
         for fee in fees.iter() {
             let tx2_temp = node0.new_transaction(tx_hash_0.clone());
-            let output = CellOutputBuilder::default().capacity(fee).build();
+            let output = CellOutputBuilder::default().capacity(fee.pack()).build();
 
             let tx2 = tx2_temp
                 .as_advanced_builder()
@@ -931,8 +931,11 @@ impl Spec for RbfConcurrency {
             assert_eq!(*s, Status::Rejected);
         }
 
-        let mut expected: Vec<ckb_types::H256> =
-            conflicts.iter().take(4).map(|x| x.hash().into()).collect();
+        let mut expected: Vec<ckb_types::H256> = conflicts
+            .iter()
+            .take(4)
+            .map(|x| x.hash().unpack())
+            .collect();
         expected.sort_unstable();
         assert_eq!(get_tx_pool_conflicts(node0), expected);
     }
@@ -974,7 +977,7 @@ impl Spec for RbfCellDepsCheck {
         // Create a child transaction with celldep
         let tx = always_success_transaction(node0, input_c);
         let cell_dep_to_last = CellDepBuilder::default()
-            .dep_type(DepType::Code)
+            .dep_type(DepType::Code.into())
             .out_point(OutPoint::new(prev.hash(), 0))
             .build();
         let tx_c = tx
@@ -988,7 +991,7 @@ impl Spec for RbfCellDepsCheck {
 
         // Create a new transaction for cell dep with high fee
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(80))
+            .capacity(capacity_bytes!(80).pack())
             .build();
         let new_tx = tx_a
             .as_advanced_builder()
@@ -1002,7 +1005,7 @@ impl Spec for RbfCellDepsCheck {
             .unwrap()
             .to_string()
             .contains("new Tx contains cell deps from conflicts"));
-        assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().into()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().unpack()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -1160,7 +1163,7 @@ fn run_spec_send_conflict_relay(nodes: &mut [Node]) {
     let tx1 = node0.new_transaction(tx_hash_0.clone());
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(90))
+        .capacity(capacity_bytes!(90).pack())
         .build();
 
     let tx1 = tx1.as_advanced_builder().set_outputs(vec![output]).build();
@@ -1186,7 +1189,7 @@ fn run_spec_send_conflict_relay(nodes: &mut [Node]) {
     // node0 will accept it and node1 will reject it and put it in conflicts pool
     let tx2_temp = node0.new_transaction(tx_hash_0);
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(95))
+        .capacity(capacity_bytes!(95).pack())
         .build();
 
     let tx2 = tx2_temp
@@ -1208,7 +1211,7 @@ fn run_spec_send_conflict_relay(nodes: &mut [Node]) {
     assert_eq!(res.status, Status::Rejected);
     let res = node1.get_transaction(tx1.hash());
     assert_eq!(res.status, Status::Pending);
-    assert_eq!(get_tx_pool_conflicts(node1), vec![tx2.hash().into()]);
+    assert_eq!(get_tx_pool_conflicts(node1), vec![tx2.hash().unpack()]);
 }
 
 pub struct SendConflictTxToRelay;
diff --git a/test/src/specs/tx_pool/send_defected_binary.rs b/test/src/specs/tx_pool/send_defected_binary.rs
index cc5667af28..76dab8dbe3 100644
--- a/test/src/specs/tx_pool/send_defected_binary.rs
+++ b/test/src/specs/tx_pool/send_defected_binary.rs
@@ -55,10 +55,10 @@ impl Spec for SendDefectedBinary {
 
         let cell_dep = CellDep::new_builder()
             .out_point(secp_out_point)
-            .dep_type(DepType::DepGroup)
+            .dep_type(DepType::DepGroup.into())
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(5000))
+            .capacity(capacity_bytes!(5000).pack())
             .lock(node.always_success_script())
             .build();
         let data = include_bytes!("../../../../script/testdata/defected_binary");
@@ -66,12 +66,12 @@ impl Spec for SendDefectedBinary {
             .cell_dep(cell_dep.clone())
             .inputs(inputs.clone())
             .output(output.clone())
-            .output_data(&data[..])
+            .output_data(data[..].pack())
             .build();
 
         let tx_hash = tx.hash();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])))
+            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
             .build();
         let witness_len = witness.as_slice().len() as u64;
         let message = {
@@ -86,14 +86,14 @@ impl Spec for SendDefectedBinary {
         let sig = self.privkey.sign_recoverable(&message).expect("sign");
         let witness = witness
             .as_builder()
-            .lock(Some(Bytes::from(sig.serialize())))
+            .lock(Some(Bytes::from(sig.serialize())).pack())
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .inputs(inputs)
             .output(output)
-            .output_data(&data[..])
-            .witness(witness.as_bytes())
+            .output_data(data[..].pack())
+            .witness(witness.as_bytes().pack())
             .build();
         info!("Send 1 secp tx with defected binary");
 
diff --git a/test/src/specs/tx_pool/send_large_cycles_tx.rs b/test/src/specs/tx_pool/send_large_cycles_tx.rs
index 26e93c3761..ce4d4ec09e 100644
--- a/test/src/specs/tx_pool/send_large_cycles_tx.rs
+++ b/test/src/specs/tx_pool/send_large_cycles_tx.rs
@@ -13,7 +13,7 @@ use ckb_types::{
         capacity_bytes, BlockView, Capacity, DepType, ScriptHashType, TransactionBuilder,
         TransactionView,
     },
-    packed::{self, CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
+    packed::{CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
     prelude::*,
     H256,
 };
@@ -325,13 +325,13 @@ impl RandomKey {
 fn build_tx(node: &Node, privkey: &Privkey, lock_arg: Bytes) -> TransactionView {
     let secp_out_point = OutPoint::new(node.dep_group_tx_hash(), 0);
     let lock = Script::new_builder()
-        .args(lock_arg)
-        .code_hash(type_lock_script_code_hash())
-        .hash_type(ScriptHashType::Type)
+        .args(lock_arg.pack())
+        .code_hash(type_lock_script_code_hash().pack())
+        .hash_type(ScriptHashType::Type.into())
         .build();
     let cell_dep = CellDep::new_builder()
         .out_point(secp_out_point)
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
     let input1 = {
         let block = node.get_tip_block();
@@ -339,18 +339,18 @@ fn build_tx(node: &Node, privkey: &Privkey, lock_arg: Bytes) -> TransactionView
         CellInput::new(OutPoint::new(cellbase_hash, 0), 0)
     };
     let output1 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100))
+        .capacity(capacity_bytes!(100).pack())
         .lock(lock)
         .build();
     let tx = TransactionBuilder::default()
         .cell_dep(cell_dep)
         .input(input1)
         .output(output1)
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
-    let tx_hash: H256 = tx.hash().into();
+    let tx_hash: H256 = tx.hash().unpack();
     let witness = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])))
+        .lock(Some(Bytes::from(vec![0u8; 65])).pack())
         .build();
     let witness_len = witness.as_slice().len() as u64;
     let message = {
@@ -365,7 +365,9 @@ fn build_tx(node: &Node, privkey: &Privkey, lock_arg: Bytes) -> TransactionView
     let sig = privkey.sign_recoverable(&message).expect("sign");
     let witness = witness
         .as_builder()
-        .lock(Some(Bytes::from(sig.serialize())))
+        .lock(Some(Bytes::from(sig.serialize())).pack())
         .build();
-    tx.as_advanced_builder().witness(witness.as_bytes()).build()
+    tx.as_advanced_builder()
+        .witness(witness.as_bytes().pack())
+        .build()
 }
diff --git a/test/src/specs/tx_pool/send_low_fee_rate_tx.rs b/test/src/specs/tx_pool/send_low_fee_rate_tx.rs
index 40a3ebcc6a..befbf60722 100644
--- a/test/src/specs/tx_pool/send_low_fee_rate_tx.rs
+++ b/test/src/specs/tx_pool/send_low_fee_rate_tx.rs
@@ -44,7 +44,7 @@ impl Spec for SendLowFeeRateTx {
             .get(0)
             .unwrap()
             .as_builder()
-            .capacity(capacity)
+            .capacity(capacity.pack())
             .build();
         let tx_low_fee = tx_low_fee
             .data()
@@ -64,7 +64,7 @@ impl Spec for SendLowFeeRateTx {
             .get(0)
             .unwrap()
             .as_builder()
-            .capacity(capacity.safe_sub(1000u32).unwrap())
+            .capacity(capacity.safe_sub(1000u32).unwrap().pack())
             .build();
         let tx_high_fee = tx_high_fee
             .data()
diff --git a/test/src/specs/tx_pool/send_multisig_secp_tx.rs b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
index 5eb2c96694..f0de38db6f 100644
--- a/test/src/specs/tx_pool/send_multisig_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
@@ -10,7 +10,7 @@ use ckb_resource::CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL;
 use ckb_types::{
     bytes::Bytes,
     core::{capacity_bytes, Capacity, DepType, ScriptHashType, TransactionBuilder},
-    packed::{self, CellDep, CellInput, CellOutput, OutPoint, WitnessArgs},
+    packed::{CellDep, CellInput, CellOutput, OutPoint, WitnessArgs},
     prelude::*,
     H160, H256,
 };
@@ -50,10 +50,10 @@ impl Spec for SendMultiSigSecpTxUseDepGroup {
 
         let cell_dep = CellDep::new_builder()
             .out_point(secp_out_point)
-            .dep_type(DepType::DepGroup)
+            .dep_type(DepType::DepGroup.into())
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(node.always_success_script())
             .build();
         let input = CellInput::new(OutPoint::new(cellbase_hash, 0), 0);
@@ -61,7 +61,7 @@ impl Spec for SendMultiSigSecpTxUseDepGroup {
             .cell_dep(cell_dep.clone())
             .input(input.clone())
             .output(output.clone())
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         let multi_sign_script = gen_multi_sign_script(&self.keys, self.keys.len() as u8, 0);
         let tx_hash = tx.hash();
@@ -69,7 +69,7 @@ impl Spec for SendMultiSigSecpTxUseDepGroup {
             let mut lock = multi_sign_script.to_vec();
             lock.extend(vec![0u8; 65 * self.keys.len()]);
             WitnessArgs::new_builder()
-                .lock(Some(Bytes::from(lock)))
+                .lock(Some(Bytes::from(lock)).pack())
                 .build()
         };
         let witness_len = witness.as_slice().len() as u64;
@@ -88,13 +88,16 @@ impl Spec for SendMultiSigSecpTxUseDepGroup {
             let sig = key.sign_recoverable(&message).expect("sign");
             lock.extend_from_slice(&sig.serialize());
         });
-        let witness = witness.as_builder().lock(Some(Bytes::from(lock))).build();
+        let witness = witness
+            .as_builder()
+            .lock(Some(Bytes::from(lock)).pack())
+            .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .input(input)
             .output(output)
-            .output_data(packed::Bytes::default())
-            .witness(witness.as_bytes())
+            .output_data(Default::default())
+            .witness(witness.as_bytes().pack())
             .build();
         info!("Send 1 multisig tx use dep group");
 
@@ -133,7 +136,7 @@ fn gen_multi_sign_script(keys: &[Privkey], threshold: u8, require_first_n: u8) -
 fn type_lock_script_code_hash() -> H256 {
     build_genesis_type_id_script(OUTPUT_INDEX_SECP256K1_BLAKE160_MULTISIG_ALL)
         .calc_script_hash()
-        .into()
+        .unpack()
 }
 
 fn new_block_assembler_config(lock_arg: Bytes, hash_type: ScriptHashType) -> BlockAssemblerConfig {
diff --git a/test/src/specs/tx_pool/send_secp_tx.rs b/test/src/specs/tx_pool/send_secp_tx.rs
index f8970c236c..7449c7454c 100644
--- a/test/src/specs/tx_pool/send_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_secp_tx.rs
@@ -7,7 +7,7 @@ use ckb_logger::info;
 use ckb_types::{
     bytes::Bytes,
     core::{capacity_bytes, Capacity, DepType, ScriptHashType, TransactionBuilder},
-    packed::{self, CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
+    packed::{CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
     prelude::*,
     H256,
 };
@@ -47,10 +47,10 @@ impl Spec for SendSecpTxUseDepGroup {
 
         let cell_dep = CellDep::new_builder()
             .out_point(secp_out_point)
-            .dep_type(DepType::DepGroup)
+            .dep_type(DepType::DepGroup.into())
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(node.always_success_script())
             .build();
         let input = CellInput::new(OutPoint::new(cellbase_hash, 0), 0);
@@ -58,12 +58,12 @@ impl Spec for SendSecpTxUseDepGroup {
             .cell_dep(cell_dep.clone())
             .input(input.clone())
             .output(output.clone())
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx_hash = tx.hash();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])))
+            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
             .build();
         let witness_len = witness.as_slice().len() as u64;
         let message = {
@@ -78,14 +78,14 @@ impl Spec for SendSecpTxUseDepGroup {
         let sig = self.privkey.sign_recoverable(&message).expect("sign");
         let witness = witness
             .as_builder()
-            .lock(Some(Bytes::from(sig.serialize())))
+            .lock(Some(Bytes::from(sig.serialize())).pack())
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .input(input)
             .output(output)
-            .output_data(packed::Bytes::default())
-            .witness(witness.as_bytes())
+            .output_data(Default::default())
+            .witness(witness.as_bytes().pack())
             .build();
         info!("Send 1 secp tx use dep group");
 
@@ -140,7 +140,7 @@ impl Spec for CheckTypical2In2OutTx {
 
         let cell_dep = CellDep::new_builder()
             .out_point(secp_out_point)
-            .dep_type(DepType::DepGroup)
+            .dep_type(DepType::DepGroup.into())
             .build();
         let input1 = {
             let block = node.get_tip_block();
@@ -154,16 +154,16 @@ impl Spec for CheckTypical2In2OutTx {
             CellInput::new(OutPoint::new(cellbase_hash, 0), 0)
         };
         let lock = Script::new_builder()
-            .args(&self.lock_arg)
-            .code_hash(type_lock_script_code_hash())
-            .hash_type(ScriptHashType::Type)
+            .args(self.lock_arg.pack())
+            .code_hash(type_lock_script_code_hash().pack())
+            .hash_type(ScriptHashType::Type.into())
             .build();
         let output1 = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(lock.clone())
             .build();
         let output2 = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100))
+            .capacity(capacity_bytes!(100).pack())
             .lock(lock)
             .build();
         let tx = TransactionBuilder::default()
@@ -172,13 +172,13 @@ impl Spec for CheckTypical2In2OutTx {
             .input(input2)
             .output(output1)
             .output(output2)
-            .output_data(packed::Bytes::default())
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
+            .output_data(Default::default())
             .build();
 
-        let tx_hash: H256 = tx.hash().into();
+        let tx_hash: H256 = tx.hash().unpack();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])))
+            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
             .build();
         let witness_len = witness.as_slice().len() as u64;
         let witness2 = Bytes::new();
@@ -197,19 +197,20 @@ impl Spec for CheckTypical2In2OutTx {
         let sig = self.privkey.sign_recoverable(&message).expect("sign");
         let witness = witness
             .as_builder()
-            .lock(Some(Bytes::from(sig.serialize())))
+            .lock(Some(Bytes::from(sig.serialize())).pack())
             .build();
         let tx = tx
             .as_advanced_builder()
-            .witness(witness.as_bytes())
-            .witness(witness2)
+            .witness(witness.as_bytes().pack())
+            .witness(witness2.pack())
             .build();
 
         info!("Send 1 secp tx use dep group");
         node.rpc_client()
             .inner()
             .send_transaction(tx.data().into(), None)
-            .expect("should pass default outputs validator");
+            .expect("should pass default outputs validator")
+            .pack();
         node.mine(20);
 
         assert!(is_transaction_committed(node, &tx));
diff --git a/test/src/txo.rs b/test/src/txo.rs
index 98bcc997ae..7d9868b6f4 100644
--- a/test/src/txo.rs
+++ b/test/src/txo.rs
@@ -1,5 +1,5 @@
 use ckb_types::core::{Capacity, TransactionBuilder, TransactionView};
-use ckb_types::packed::{self, CellDep, CellInput, CellOutput, OutPoint, Script, ScriptOpt};
+use ckb_types::packed::{CellDep, CellInput, CellOutput, OutPoint, Script, ScriptOpt};
 use ckb_types::prelude::*;
 use rand::{thread_rng, Rng};
 use std::collections::HashMap;
@@ -31,7 +31,7 @@ impl TXO {
     }
 
     pub fn capacity(&self) -> u64 {
-        self.output.capacity().into()
+        self.output.capacity().unpack()
     }
 
     pub fn lock(&self) -> Script {
@@ -52,7 +52,7 @@ impl TXO {
     pub fn to_equivalent_output(&self) -> CellOutput {
         CellOutput::new_builder()
             .lock(self.lock())
-            .capacity(self.capacity())
+            .capacity(self.capacity().pack())
             .build()
     }
 
@@ -145,7 +145,7 @@ impl TXOSet {
                     .cell_deps(cell_deps.clone())
                     .input(txo.to_input())
                     .output(txo.to_equivalent_output())
-                    .output_data(packed::Bytes::default())
+                    .output_data(Default::default())
                     .build()
             })
             .collect()
@@ -161,18 +161,18 @@ impl TXOSet {
         self.iter()
             .map(|txo| {
                 let maximal_capacity = txo.capacity();
-                let minimal_capacity: u64 = txo.to_minimal_output().capacity().into();
+                let minimal_capacity: u64 = txo.to_minimal_output().capacity().unpack();
                 let actual_capacity = rng.gen_range(minimal_capacity..=maximal_capacity);
                 let output = txo
                     .to_equivalent_output()
                     .as_builder()
-                    .capacity(actual_capacity)
+                    .capacity(actual_capacity.pack())
                     .build();
                 TransactionBuilder::default()
                     .cell_deps(cell_deps.clone())
                     .input(txo.to_input())
                     .output(output)
-                    .output_data(packed::Bytes::default())
+                    .output_data(Default::default())
                     .build()
             })
             .collect()
@@ -181,11 +181,11 @@ impl TXOSet {
     fn boom_to_minimals(&self) -> Vec<CellOutput> {
         let mut input_capacity = self.total_capacity();
         let minimal = self.iter().next().unwrap().to_minimal_output();
-        let minimal_capacity: u64 = minimal.capacity().into();
+        let minimal_capacity: u64 = minimal.capacity().unpack();
         let mut outputs = Vec::new();
         while outputs.len() < EXPLODE_LIMIT {
             if input_capacity < 2 * minimal_capacity || outputs.len() == EXPLODE_LIMIT {
-                outputs.push(minimal.as_builder().capacity(input_capacity).build());
+                outputs.push(minimal.as_builder().capacity(input_capacity.pack()).build());
                 break;
             } else {
                 input_capacity -= minimal_capacity;
@@ -214,7 +214,7 @@ impl From<&TransactionView> for TXOSet {
             .map(move |(i, output)| {
                 let out_point = OutPoint::new_builder()
                     .tx_hash(tx_hash.clone())
-                    .index(i)
+                    .index(i.pack())
                     .build();
                 TXO::new(out_point, output)
             });
diff --git a/test/src/util/cell.rs b/test/src/util/cell.rs
index 37aaea9c03..78a2303235 100644
--- a/test/src/util/cell.rs
+++ b/test/src/util/cell.rs
@@ -102,6 +102,6 @@ pub fn as_output(cell: &CellMeta) -> CellOutput {
     CellOutput::new_builder()
         .lock(cell.cell_output.lock())
         .type_(cell.cell_output.type_())
-        .capacity(cell.capacity())
+        .capacity(cell.capacity().pack())
         .build()
 }
diff --git a/test/src/util/mining.rs b/test/src/util/mining.rs
index 17bd1ff87c..ebbf686522 100644
--- a/test/src/util/mining.rs
+++ b/test/src/util/mining.rs
@@ -147,7 +147,7 @@ impl Node {
             !template
                 .transactions
                 .iter()
-                .any(|tx| tx.hash == tx_hash.into())
+                .any(|tx| tx.hash == tx_hash.unpack())
         });
     }
 
diff --git a/test/src/util/transaction.rs b/test/src/util/transaction.rs
index 230251d56c..35e640cd64 100644
--- a/test/src/util/transaction.rs
+++ b/test/src/util/transaction.rs
@@ -20,7 +20,7 @@ pub fn always_success_transaction(node: &Node, cell: &CellMeta) -> TransactionVi
     TransactionBuilder::default()
         .input(as_input(cell))
         .output(as_output(cell))
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .cell_dep(node.always_success_cell_dep())
         .build()
 }
@@ -39,7 +39,7 @@ pub fn always_success_transactions_with_rand_data(
                     (0..1600)
                         .map(|_| rand::random::<u8>())
                         .collect::<Vec<_>>()
-                        .into()
+                        .pack()
                 })
                 .collect::<Vec<packed::Bytes>>(),
         )
@@ -49,7 +49,7 @@ pub fn always_success_transactions_with_rand_data(
 
 pub fn send_tx(net: &Net, node: &Node, tx: TransactionView, cycles: u64) {
     let relay_tx = packed::RelayTransaction::new_builder()
-        .cycles(cycles)
+        .cycles(cycles.pack())
         .transaction(tx.data())
         .build();
 
@@ -71,7 +71,7 @@ pub fn relay_tx(net: &Net, node: &Node, tx: TransactionView, cycles: u64) {
     let tx_hashes_msg = packed::RelayMessage::new_builder()
         .set(
             packed::RelayTransactionHashes::new_builder()
-                .tx_hashes(vec![tx.hash()])
+                .tx_hashes(vec![tx.hash()].pack())
                 .build(),
         )
         .build();
@@ -85,7 +85,7 @@ pub fn relay_tx(net: &Net, node: &Node, tx: TransactionView, cycles: u64) {
     assert!(ret, "node should ask for tx");
 
     let relay_tx = packed::RelayTransaction::new_builder()
-        .cycles(cycles)
+        .cycles(cycles.pack())
         .transaction(tx.data())
         .build();
 
diff --git a/test/src/utils.rs b/test/src/utils.rs
index c566e874c9..57d9227ac9 100644
--- a/test/src/utils.rs
+++ b/test/src/utils.rs
@@ -5,7 +5,7 @@ use ckb_network::bytes::Bytes;
 use ckb_types::{
     core::{BlockNumber, BlockView, EpochNumberWithFraction, HeaderView, TransactionView},
     packed::{
-        self, BlockFilterMessage, BlockTransactions, Byte32, CompactBlock, GetBlocks, RelayMessage,
+        BlockFilterMessage, BlockTransactions, Byte32, CompactBlock, GetBlocks, RelayMessage,
         RelayTransaction, RelayTransactionHashes, RelayTransactions, SendBlock, SendHeaders,
         SyncMessage,
     },
@@ -55,7 +55,7 @@ pub fn build_block_transactions(block: &BlockView) -> Bytes {
                 .into_iter()
                 .map(|view| view.data())
                 .skip(1)
-                .collect::<Vec<packed::Transaction>>(),
+                .pack(),
         )
         .build();
 
@@ -71,7 +71,13 @@ pub fn build_header(header: &HeaderView) -> Bytes {
 
 pub fn build_headers(headers: &[HeaderView]) -> Bytes {
     let send_headers = SendHeaders::new_builder()
-        .headers(headers.iter().map(|view| view.data()).collect::<Vec<_>>())
+        .headers(
+            headers
+                .iter()
+                .map(|view| view.data())
+                .collect::<Vec<_>>()
+                .pack(),
+        )
         .build();
 
     SyncMessage::new_builder()
@@ -89,12 +95,7 @@ pub fn build_block(block: &BlockView) -> Bytes {
 
 pub fn build_get_blocks(hashes: &[Byte32]) -> Bytes {
     let get_blocks = GetBlocks::new_builder()
-        .block_hashes(
-            hashes
-                .iter()
-                .map(ToOwned::to_owned)
-                .collect::<Vec<packed::Byte32>>(),
-        )
+        .block_hashes(hashes.iter().map(ToOwned::to_owned).pack())
         .build();
 
     SyncMessage::new_builder()
@@ -104,17 +105,14 @@ pub fn build_get_blocks(hashes: &[Byte32]) -> Bytes {
 }
 
 pub fn build_relay_txs(transactions: &[(TransactionView, u64)]) -> Bytes {
-    let transactions = transactions
-        .iter()
-        .map(|(tx, cycles)| {
-            RelayTransaction::new_builder()
-                .cycles(cycles)
-                .transaction(tx.data())
-                .build()
-        })
-        .collect::<Vec<packed::RelayTransaction>>();
+    let transactions = transactions.iter().map(|(tx, cycles)| {
+        RelayTransaction::new_builder()
+            .cycles(cycles.pack())
+            .transaction(tx.data())
+            .build()
+    });
     let txs = RelayTransactions::new_builder()
-        .transactions(transactions)
+        .transactions(transactions.pack())
         .build();
 
     RelayMessage::new_builder().set(txs).build().as_bytes()
@@ -122,12 +120,7 @@ pub fn build_relay_txs(transactions: &[(TransactionView, u64)]) -> Bytes {
 
 pub fn build_relay_tx_hashes(hashes: &[Byte32]) -> Bytes {
     let content = RelayTransactionHashes::new_builder()
-        .tx_hashes(
-            hashes
-                .iter()
-                .map(ToOwned::to_owned)
-                .collect::<Vec<Byte32>>(),
-        )
+        .tx_hashes(hashes.iter().map(ToOwned::to_owned).pack())
         .build();
 
     RelayMessage::new_builder().set(content).build().as_bytes()
diff --git a/tx-pool/src/block_assembler/mod.rs b/tx-pool/src/block_assembler/mod.rs
index dfa9ce3c02..81acca0951 100644
--- a/tx-pool/src/block_assembler/mod.rs
+++ b/tx-pool/src/block_assembler/mod.rs
@@ -459,9 +459,9 @@ impl BlockAssembler {
     ) -> CellbaseWitness {
         let hash_type: ScriptHashType = config.hash_type.clone().into();
         let cellbase_lock = Script::new_builder()
-            .args(config.args.as_bytes())
-            .code_hash(&config.code_hash)
-            .hash_type(hash_type)
+            .args(config.args.as_bytes().pack())
+            .code_hash(config.code_hash.pack())
+            .hash_type(hash_type.into())
             .build();
         let tip = snapshot.tip_header();
 
@@ -480,7 +480,7 @@ impl BlockAssembler {
 
         CellbaseWitness::new_builder()
             .lock(cellbase_lock)
-            .message(message)
+            .message(message.pack())
             .build()
     }
 
@@ -502,11 +502,11 @@ impl BlockAssembler {
             })?;
             let input = CellInput::new_cellbase_input(candidate_number);
             let output = CellOutput::new_builder()
-                .capacity(block_reward.total)
+                .capacity(block_reward.total.pack())
                 .lock(target_lock)
                 .build();
 
-            let witness = cellbase_witness.as_bytes();
+            let witness = cellbase_witness.as_bytes().pack();
             let no_finalization_target =
                 candidate_number <= snapshot.consensus().finalization_delay_length();
             let tx_builder = TransactionBuilder::default().input(input).witness(witness);
@@ -536,7 +536,7 @@ impl BlockAssembler {
                 .chain_root_mmr(tip_header.number())
                 .get_root()
                 .map_err(|e| InternalErrorKind::MMR.other(e))?;
-            let bytes = chain_root.calc_mmr_hash().as_bytes().into();
+            let bytes = chain_root.calc_mmr_hash().as_bytes().pack();
             Ok(Some(bytes))
         } else {
             Ok(None)
@@ -564,28 +564,18 @@ impl BlockAssembler {
         let block = if let Some(extension) = extension_opt {
             packed::BlockV1::new_builder()
                 .header(header)
-                .transactions(vec![cellbase])
-                .uncles(
-                    uncles
-                        .iter()
-                        .map(|u| u.data())
-                        .collect::<Vec<packed::UncleBlock>>(),
-                )
-                .proposals(proposals.cloned().collect::<Vec<_>>())
+                .transactions(vec![cellbase].pack())
+                .uncles(uncles.iter().map(|u| u.data()).pack())
+                .proposals(proposals.cloned().collect::<Vec<_>>().pack())
                 .extension(extension)
                 .build()
                 .as_v0()
         } else {
             packed::Block::new_builder()
                 .header(header)
-                .transactions(vec![cellbase])
-                .uncles(
-                    uncles
-                        .iter()
-                        .map(|u| u.data())
-                        .collect::<Vec<packed::UncleBlock>>(),
-                )
-                .proposals(proposals.cloned().collect::<Vec<_>>())
+                .transactions(vec![cellbase].pack())
+                .uncles(uncles.iter().map(|u| u.data()).pack())
+                .proposals(proposals.cloned().collect::<Vec<_>>().pack())
                 .build()
         };
         block.serialized_size_without_uncle_proposals()
@@ -738,7 +728,7 @@ impl<'a> From<&'a BlockTemplate> for JsonBlockTemplate {
             compact_target: template.compact_target.into(),
             number: template.number.into(),
             epoch: template.epoch.into(),
-            parent_hash: (&template.parent_hash).into(),
+            parent_hash: template.parent_hash.unpack(),
             cycles_limit: template.cycles_limit.into(),
             bytes_limit: template.bytes_limit.into(),
             uncles_count_limit: u64::from(template.uncles_count_limit).into(),
@@ -928,7 +918,7 @@ impl BlockTemplateBuilder {
 
 pub(crate) fn uncle_to_template(uncle: &UncleBlockView) -> UncleTemplate {
     UncleTemplate {
-        hash: uncle.hash().into(),
+        hash: uncle.hash().unpack(),
         required: false,
         proposals: uncle
             .data()
@@ -942,7 +932,7 @@ pub(crate) fn uncle_to_template(uncle: &UncleBlockView) -> UncleTemplate {
 
 pub(crate) fn tx_entry_to_template(entry: &TxEntry) -> TransactionTemplate {
     TransactionTemplate {
-        hash: entry.transaction().hash().into(),
+        hash: entry.transaction().hash().unpack(),
         required: false, // unimplemented
         cycles: Some(entry.cycles.into()),
         depends: None, // unimplemented
@@ -952,7 +942,7 @@ pub(crate) fn tx_entry_to_template(entry: &TxEntry) -> TransactionTemplate {
 
 pub(crate) fn cellbase_to_template(tx: &TransactionView) -> CellbaseTemplate {
     CellbaseTemplate {
-        hash: tx.hash().into(),
+        hash: tx.hash().unpack(),
         cycles: None,
         data: tx.data().into(),
     }
diff --git a/tx-pool/src/block_assembler/tests.rs b/tx-pool/src/block_assembler/tests.rs
index 4b9f15a5fd..6d39933ecb 100644
--- a/tx-pool/src/block_assembler/tests.rs
+++ b/tx-pool/src/block_assembler/tests.rs
@@ -1,4 +1,7 @@
-use ckb_types::core::{BlockBuilder, BlockNumber, EpochNumberWithFraction};
+use ckb_types::{
+    core::{BlockBuilder, BlockNumber, EpochNumberWithFraction},
+    prelude::*,
+};
 
 use crate::block_assembler::candidate_uncles::{
     CandidateUncles, MAX_CANDIDATE_UNCLES, MAX_PER_HEIGHT,
@@ -27,12 +30,8 @@ fn test_candidate_uncles_max_size() {
     for i in 0..(MAX_CANDIDATE_UNCLES + 3) {
         let number = i as BlockNumber;
         let block = BlockBuilder::default()
-            .number(number)
-            .epoch(EpochNumberWithFraction::new(
-                number / 1000,
-                number % 1000,
-                10000,
-            ))
+            .number(number.pack())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 10000).pack())
             .build()
             .as_uncle();
         blocks.push(block);
@@ -61,7 +60,7 @@ fn test_candidate_uncles_max_per_height() {
     let mut blocks = Vec::new();
     for i in 0..(MAX_PER_HEIGHT + 3) {
         let block = BlockBuilder::default()
-            .timestamp(i as u64)
+            .timestamp((i as u64).pack())
             .build()
             .as_uncle();
         blocks.push(block);
diff --git a/tx-pool/src/component/pool_map.rs b/tx-pool/src/component/pool_map.rs
index b62f55d4c6..575452785c 100644
--- a/tx-pool/src/component/pool_map.rs
+++ b/tx-pool/src/component/pool_map.rs
@@ -11,6 +11,7 @@ use ckb_logger::{debug, error, trace};
 use ckb_types::core::error::OutPointError;
 use ckb_types::core::Cycle;
 use ckb_types::packed::OutPoint;
+use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::TransactionView,
@@ -185,7 +186,7 @@ impl PoolMap {
             .and_then(|entry| {
                 entry
                     .transaction()
-                    .output_with_data(out_point.index().into())
+                    .output_with_data(out_point.index().unpack())
             })
     }
 
diff --git a/tx-pool/src/component/tests/chunk.rs b/tx-pool/src/component/tests/chunk.rs
index 9f4f2f1a31..39df2dc1cd 100644
--- a/tx-pool/src/component/tests/chunk.rs
+++ b/tx-pool/src/component/tests/chunk.rs
@@ -2,6 +2,7 @@ use crate::component::tests::util::build_tx;
 use crate::component::verify_queue::{Entry, VerifyQueue};
 use ckb_network::SessionId;
 use ckb_types::core::TransactionBuilder;
+use ckb_types::prelude::Pack;
 use ckb_types::H256;
 use tokio::select;
 use tokio::sync::watch;
@@ -94,22 +95,22 @@ async fn test_verify_different_cycles() {
 
     let remote = |cycles| Some((cycles, SessionId::default()));
 
-    let tx0 = build_tx(vec![(&H256([0; 32]).into(), 0)], 1);
+    let tx0 = build_tx(vec![(&H256([0; 32]).pack(), 0)], 1);
     assert!(queue.add_tx(tx0.clone(), remote(1001)).unwrap());
     sleep(std::time::Duration::from_millis(100)).await;
 
-    let tx1 = build_tx(vec![(&H256([1; 32]).into(), 0)], 1);
+    let tx1 = build_tx(vec![(&H256([1; 32]).pack(), 0)], 1);
     assert!(queue
         .add_tx(tx1.clone(), remote(MAX_TX_VERIFY_CYCLES + 1))
         .unwrap());
     sleep(std::time::Duration::from_millis(100)).await;
 
-    let tx2 = build_tx(vec![(&H256([2; 32]).into(), 0)], 1);
+    let tx2 = build_tx(vec![(&H256([2; 32]).pack(), 0)], 1);
     assert!(queue.add_tx(tx2.clone(), remote(1001)).unwrap());
     sleep(std::time::Duration::from_millis(100)).await;
     // now queue should be sorted by time (tx1, tx2)
 
-    let tx3 = build_tx(vec![(&H256([3; 32]).into(), 0)], 1);
+    let tx3 = build_tx(vec![(&H256([3; 32]).pack(), 0)], 1);
     assert!(queue.add_tx(tx3.clone(), remote(1001)).unwrap());
     sleep(std::time::Duration::from_millis(100)).await;
 
diff --git a/tx-pool/src/component/tests/pending.rs b/tx-pool/src/component/tests/pending.rs
index bcef42ef01..e262248354 100644
--- a/tx-pool/src/component/tests/pending.rs
+++ b/tx-pool/src/component/tests/pending.rs
@@ -8,7 +8,7 @@ use crate::component::{
 };
 use ckb_types::core::Capacity;
 use ckb_types::packed::OutPoint;
-use ckb_types::{h256, packed::Byte32};
+use ckb_types::{h256, packed::Byte32, prelude::*};
 use std::collections::HashSet;
 use std::time::Duration;
 
@@ -18,7 +18,7 @@ fn test_basic() {
     assert_eq!(pool.size(), 0);
     let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&Byte32::zero(), 2)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 2)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 2)],
         3,
     );
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
@@ -51,21 +51,21 @@ fn test_basic() {
 #[test]
 fn test_resolve_conflict() {
     let mut pool = PoolMap::new(100);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").into(), 1)],
-        vec![(&h256!("0x5").into(), 1)],
+        vec![(&h256!("0x4").pack(), 1)],
+        vec![(&h256!("0x5").pack(), 1)],
         3,
     );
     let tx4 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x1").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x1").pack(), 1)],
         3,
     );
-    let tx5 = build_tx(vec![(&h256!("0x5").into(), 1)], 3);
+    let tx5 = build_tx(vec![(&h256!("0x5").pack(), 1)], 3);
 
     let entry1 = TxEntry::dummy_resolve(tx1, MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
     let entry2 = TxEntry::dummy_resolve(tx2, MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
@@ -114,9 +114,9 @@ fn test_resolve_conflict_descendants() {
 fn test_resolve_conflict_header_dep() {
     let mut pool = PoolMap::new(1000);
 
-    let header: Byte32 = h256!("0x1").into();
+    let header: Byte32 = h256!("0x1").pack();
     let tx = build_tx_with_header_dep(
-        vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)],
+        vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)],
         vec![header.clone()],
         1,
     );
@@ -143,9 +143,9 @@ fn test_resolve_conflict_header_dep() {
 #[test]
 fn test_remove_entry() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
-    let header: Byte32 = h256!("0x1").into();
-    let tx2 = build_tx_with_header_dep(vec![(&h256!("0x2").into(), 1)], vec![header], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
+    let header: Byte32 = h256!("0x1").pack();
+    let tx2 = build_tx_with_header_dep(vec![(&h256!("0x2").pack(), 1)], vec![header], 1);
 
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
     let entry2 = TxEntry::dummy_resolve(tx2.clone(), MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
@@ -165,14 +165,14 @@ fn test_remove_entry() {
 #[test]
 fn test_get_proposals() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").into(), 1)],
-        vec![(&h256!("0x5").into(), 1)],
+        vec![(&h256!("0x4").pack(), 1)],
+        vec![(&h256!("0x5").pack(), 1)],
         3,
     );
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
@@ -214,14 +214,14 @@ fn test_get_proposals() {
 #[test]
 fn test_get_proposals_with_high_score() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").into(), 1)],
-        vec![(&h256!("0x5").into(), 1)],
+        vec![(&h256!("0x4").pack(), 1)],
+        vec![(&h256!("0x5").pack(), 1)],
         3,
     );
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
@@ -258,8 +258,8 @@ fn test_get_proposals_with_high_score() {
 
 #[test]
 fn test_edges() {
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
-    let tx2 = build_tx(vec![(&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
+    let tx2 = build_tx(vec![(&h256!("0x1").pack(), 1)], 1);
 
     let short_id1 = tx1.proposal_short_id();
     let short_id2 = tx2.proposal_short_id();
@@ -277,14 +277,14 @@ fn test_edges() {
 #[test]
 fn test_pool_evict() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").into(), 1)],
-        vec![(&h256!("0x5").into(), 1)],
+        vec![(&h256!("0x4").pack(), 1)],
+        vec![(&h256!("0x5").pack(), 1)],
         3,
     );
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
@@ -315,14 +315,14 @@ fn test_pool_evict() {
 #[test]
 fn test_pool_min_weight_evict() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").into(), 1)],
-        vec![(&h256!("0x5").into(), 1)],
+        vec![(&h256!("0x4").pack(), 1)],
+        vec![(&h256!("0x5").pack(), 1)],
         3,
     );
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), 2, Capacity::shannons(100), 2);
@@ -353,14 +353,14 @@ fn test_pool_min_weight_evict() {
 #[test]
 fn test_pool_max_size_evict() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").into(), 1)],
-        vec![(&h256!("0x5").into(), 1)],
+        vec![(&h256!("0x4").pack(), 1)],
+        vec![(&h256!("0x5").pack(), 1)],
         3,
     );
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), 2, Capacity::shannons(100), 3);
@@ -391,9 +391,9 @@ fn test_pool_max_size_evict() {
 #[test]
 fn test_pool_min_descendants_evict() {
     let mut pool = PoolMap::new(1000);
-    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
-    let tx2 = build_tx(vec![(&tx1.hash(), 1), (&h256!("0x3").into(), 1)], 3);
-    let tx3 = build_tx_with_dep(vec![(&tx2.hash(), 1)], vec![(&h256!("0x5").into(), 1)], 3);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)], 1);
+    let tx2 = build_tx(vec![(&tx1.hash(), 1), (&h256!("0x3").pack(), 1)], 3);
+    let tx3 = build_tx_with_dep(vec![(&tx2.hash(), 1)], vec![(&h256!("0x5").pack(), 1)], 3);
     let entry1 = TxEntry::dummy_resolve(tx1.clone(), 2, Capacity::shannons(100), 1);
     std::thread::sleep(Duration::from_millis(1));
     let entry2 = TxEntry::dummy_resolve(tx2.clone(), 2, Capacity::shannons(100), 1);
diff --git a/tx-pool/src/component/tests/proposed.rs b/tx-pool/src/component/tests/proposed.rs
index ecac84398b..236d4b10a9 100644
--- a/tx-pool/src/component/tests/proposed.rs
+++ b/tx-pool/src/component/tests/proposed.rs
@@ -4,7 +4,7 @@ use crate::component::tests::util::{
     MOCK_CYCLES, MOCK_FEE, MOCK_SIZE,
 };
 use ckb_types::core::{capacity_bytes, ScriptHashType};
-use ckb_types::packed::{self, CellOutputBuilder, ScriptBuilder};
+use ckb_types::packed::{CellOutputBuilder, ScriptBuilder};
 use ckb_types::H256;
 use std::time::Instant;
 
@@ -197,7 +197,7 @@ fn test_add_entry_from_detached() {
 fn test_add_roots() {
     let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&Byte32::zero(), 2)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 2)],
+        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 2)],
         3,
     );
 
@@ -517,36 +517,36 @@ fn test_get_ancestors() {
 
 #[test]
 fn test_dep_group() {
-    let tx1 = build_tx(vec![(&h256!("0x1").into(), 0)], 1);
+    let tx1 = build_tx(vec![(&h256!("0x1").pack(), 0)], 1);
     let tx1_out_point = OutPoint::new(tx1.hash(), 0);
 
     // Dep group cell
-    let tx2_data = Into::<packed::OutPointVec>::into(vec![tx1_out_point.clone()]).as_bytes();
+    let tx2_data = vec![tx1_out_point.clone()].pack().as_bytes();
     let tx2 = TransactionBuilder::default()
-        .input(CellInput::new(OutPoint::new(h256!("0x2").into(), 0), 0))
+        .input(CellInput::new(OutPoint::new(h256!("0x2").pack(), 0), 0))
         .output(
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(1000).unwrap())
+                .capacity(Capacity::bytes(1000).unwrap().pack())
                 .build(),
         )
-        .output_data(&tx2_data)
+        .output_data(tx2_data.pack())
         .build();
     let tx2_out_point = OutPoint::new(tx2.hash(), 0);
 
     // Transaction use dep group
     let dep = CellDep::new_builder()
         .out_point(tx2_out_point.clone())
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
     let tx3 = TransactionBuilder::default()
         .cell_dep(dep)
-        .input(CellInput::new(OutPoint::new(h256!("0x3").into(), 0), 0))
+        .input(CellInput::new(OutPoint::new(h256!("0x3").pack(), 0), 0))
         .output(
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(3).unwrap())
+                .capacity(Capacity::bytes(3).unwrap().pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
     let tx3_out_point = OutPoint::new(tx3.hash(), 0);
 
@@ -590,9 +590,9 @@ fn test_dep_group() {
 fn test_resolve_conflict_header_dep() {
     let mut pool = PoolMap::new(DEFAULT_MAX_ANCESTORS_COUNT);
 
-    let header: Byte32 = h256!("0x1").into();
+    let header: Byte32 = h256!("0x1").pack();
     let tx = build_tx_with_header_dep(
-        vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)],
+        vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)],
         vec![header.clone()],
         1,
     );
@@ -672,12 +672,12 @@ fn test_max_ancestors_with_dep() {
     let mut pool = PoolMap::new(1);
     let tx1 = build_tx_with_dep(
         vec![(&Byte32::zero(), 0)],
-        vec![(&h256!("0x1").into(), 0)],
+        vec![(&h256!("0x1").pack(), 0)],
         1,
     );
     let tx1_id = tx1.proposal_short_id();
     let tx1_hash = tx1.hash();
-    let tx2 = build_tx_with_dep(vec![(&tx1_hash, 0)], vec![(&h256!("0x2").into(), 0)], 1);
+    let tx2 = build_tx_with_dep(vec![(&tx1_hash, 0)], vec![(&h256!("0x2").pack(), 0)], 1);
     let entry1 = TxEntry::dummy_resolve(tx1, MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
     let entry2 = TxEntry::dummy_resolve(tx2, MOCK_CYCLES, MOCK_FEE, MOCK_SIZE);
 
@@ -687,7 +687,7 @@ fn test_max_ancestors_with_dep() {
     assert!(pool
         .edges
         .deps
-        .contains_key(&OutPoint::new(h256!("0x1").into(), 0)));
+        .contains_key(&OutPoint::new(h256!("0x1").pack(), 0)));
     assert!(pool.calc_descendants(&tx1_id).is_empty());
 
     assert_eq!(pool.edges.inputs_len(), 1);
@@ -716,12 +716,12 @@ fn test_container_bench_add_limits() {
                         .previous_output(
                             OutPoint::new_builder()
                                 .tx_hash(prev_tx.transaction().hash())
-                                .index(0u32)
+                                .index(0u32.pack())
                                 .build(),
                         )
                         .build(),
                 )
-                .witness(Bytes::new())
+                .witness(Bytes::new().pack())
                 .build(),
             rng.gen_range(0..1000),
             Capacity::shannons(200),
@@ -748,26 +748,26 @@ fn test_pool_map_bench() {
     let mut time_spend = vec![];
     for i in 0..20000 {
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let tx = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1)
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let entry = TxEntry::dummy_resolve(
diff --git a/tx-pool/src/component/tests/score_key.rs b/tx-pool/src/component/tests/score_key.rs
index 0155fa710c..c12cc7426c 100644
--- a/tx-pool/src/component/tests/score_key.rs
+++ b/tx-pool/src/component/tests/score_key.rs
@@ -111,12 +111,12 @@ fn test_remove_entry() {
                     .previous_output(
                         OutPoint::new_builder()
                             .tx_hash(tx1.transaction().hash())
-                            .index(0u32)
+                            .index(0u32.pack())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new())
+            .witness(Bytes::new().pack())
             .build(),
         200,
         Capacity::shannons(200),
@@ -129,12 +129,12 @@ fn test_remove_entry() {
                     .previous_output(
                         OutPoint::new_builder()
                             .tx_hash(tx2.transaction().hash())
-                            .index(0u32)
+                            .index(0u32.pack())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new())
+            .witness(Bytes::new().pack())
             .build(),
         200,
         Capacity::shannons(200),
@@ -184,12 +184,12 @@ fn test_remove_entry_and_descendants() {
                     .previous_output(
                         OutPoint::new_builder()
                             .tx_hash(tx1.transaction().hash())
-                            .index(0u32)
+                            .index(0u32.pack())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new())
+            .witness(Bytes::new().pack())
             .build(),
         200,
         Capacity::shannons(200),
@@ -202,12 +202,12 @@ fn test_remove_entry_and_descendants() {
                     .previous_output(
                         OutPoint::new_builder()
                             .tx_hash(tx2.transaction().hash())
-                            .index(0u32)
+                            .index(0u32.pack())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new())
+            .witness(Bytes::new().pack())
             .build(),
         200,
         Capacity::shannons(200),
diff --git a/tx-pool/src/component/tests/util.rs b/tx-pool/src/component/tests/util.rs
index d55d37262e..32d4563d61 100644
--- a/tx-pool/src/component/tests/util.rs
+++ b/tx-pool/src/component/tests/util.rs
@@ -19,10 +19,10 @@ pub(crate) fn build_tx(inputs: Vec<(&Byte32, u32)>, outputs_len: usize) -> Trans
         )
         .outputs((0..outputs_len).map(|i| {
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(i + 1).unwrap())
+                .capacity(Capacity::bytes(i + 1).unwrap().pack())
                 .build()
         }))
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
         .build()
 }
 
@@ -44,10 +44,10 @@ pub(crate) fn build_tx_with_dep(
         }))
         .outputs((0..outputs_len).map(|i| {
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(i + 1).unwrap())
+                .capacity(Capacity::bytes(i + 1).unwrap().pack())
                 .build()
         }))
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
         .build()
 }
 
@@ -65,9 +65,9 @@ pub(crate) fn build_tx_with_header_dep(
         .set_header_deps(header_deps)
         .outputs((0..outputs_len).map(|i| {
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(i + 1).unwrap())
+                .capacity(Capacity::bytes(i + 1).unwrap().pack())
                 .build()
         }))
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
         .build()
 }
diff --git a/util/dao/src/lib.rs b/util/dao/src/lib.rs
index eb56e7df3e..ebb550871c 100644
--- a/util/dao/src/lib.rs
+++ b/util/dao/src/lib.rs
@@ -197,7 +197,7 @@ impl<'a, DL: CellDataProvider + EpochProvider + HeaderProvider> DaoCalculator<'a
             let tx_input_capacities = rtx.resolved_inputs.iter().try_fold(
                 Capacity::zero(),
                 |tx_capacities, cell_meta| {
-                    let output_capacity: Capacity = cell_meta.cell_output.capacity().into();
+                    let output_capacity: Capacity = cell_meta.cell_output.capacity().unpack();
                     tx_capacities.safe_add(output_capacity)
                 },
             )?;
@@ -248,11 +248,14 @@ impl<'a, DL: CellDataProvider + EpochProvider + HeaderProvider> DaoCalculator<'a
                             .ok_or(DaoError::InvalidOutPoint)
                             .and_then(|witness_data| {
                                 // dao contract stores header deps index as u64 in the input_type field of WitnessArgs
-                                let witness =
-                                    WitnessArgs::from_slice(&Into::<Bytes>::into(witness_data))
-                                        .map_err(|_| DaoError::InvalidDaoFormat)?;
-                                let header_deps_index_data: Option<Bytes> =
-                                    witness.input_type().to_opt().map(|witness| witness.into());
+                                let witness = WitnessArgs::from_slice(&Unpack::<Bytes>::unpack(
+                                    &witness_data,
+                                ))
+                                .map_err(|_| DaoError::InvalidDaoFormat)?;
+                                let header_deps_index_data: Option<Bytes> = witness
+                                    .input_type()
+                                    .to_opt()
+                                    .map(|witness| witness.unpack());
                                 if header_deps_index_data.is_none()
                                     || header_deps_index_data.clone().map(|data| data.len())
                                         != Some(8)
@@ -275,7 +278,7 @@ impl<'a, DL: CellDataProvider + EpochProvider + HeaderProvider> DaoCalculator<'a
                             withdrawing_header_hash,
                         )
                     } else {
-                        Ok(output.capacity().into())
+                        Ok(output.capacity().unpack())
                     }
                 };
                 capacity.and_then(|c| c.safe_add(capacities).map_err(Into::into))
@@ -307,7 +310,7 @@ impl<'a, DL: CellDataProvider + EpochProvider + HeaderProvider> DaoCalculator<'a
         let (withdrawing_ar, _, _, _) = extract_dao_data(withdrawing_header.dao());
 
         let occupied_capacity = output.occupied_capacity(output_data_capacity)?;
-        let output_capacity: Capacity = output.capacity().into();
+        let output_capacity: Capacity = output.capacity().unpack();
         let counted_capacity = output_capacity.safe_sub(occupied_capacity)?;
         let withdraw_counted_capacity = u128::from(counted_capacity.as_u64())
             * u128::from(withdrawing_ar)
@@ -330,7 +333,7 @@ pub fn modified_occupied_capacity(
             && tx_info.is_cellbase()
             && cell_meta.cell_output.lock().args().raw_data() == consensus.satoshi_pubkey_hash.0[..]
         {
-            return Into::<Capacity>::into(&cell_meta.cell_output.capacity())
+            return Unpack::<Capacity>::unpack(&cell_meta.cell_output.capacity())
                 .safe_mul_ratio(consensus.satoshi_cell_occupied_ratio);
         }
     }
diff --git a/util/dao/src/tests.rs b/util/dao/src/tests.rs
index 7ac4ecb24f..bbb4c2cf36 100644
--- a/util/dao/src/tests.rs
+++ b/util/dao/src/tests.rs
@@ -40,12 +40,12 @@ fn prepare_store(
         .base_block_reward(Capacity::shannons(50_000_000_000))
         .remainder_reward(Capacity::shannons(1_000_128))
         .previous_epoch_hash_rate(U256::one())
-        .last_block_hash_in_previous_epoch(h256!("0x1").into())
+        .last_block_hash_in_previous_epoch(h256!("0x1").pack())
         .start_number(epoch_start.unwrap_or_else(|| parent.number() - 1000))
         .length(2091)
         .compact_target(DIFF_TWO)
         .build();
-    let epoch_hash = h256!("0x123455").into();
+    let epoch_hash = h256!("0x123455").pack();
 
     txn.insert_block_epoch_index(&parent.hash(), &epoch_hash)
         .unwrap();
@@ -63,8 +63,8 @@ fn check_dao_data_calculation() {
     let parent_number = 12345;
     let epoch = EpochNumberWithFraction::new(12, 345, 1000);
     let parent_header = HeaderBuilder::default()
-        .number(parent_number)
-        .epoch(epoch)
+        .number(parent_number.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_000_123_456,
             Capacity::shannons(500_000_000_123_000),
@@ -95,7 +95,7 @@ fn check_initial_dao_data_calculation() {
 
     let parent_number = 0;
     let parent_header = HeaderBuilder::default()
-        .number(parent_number)
+        .number(parent_number.pack())
         .dao(pack_dao_data(
             10_000_000_000_000_000,
             Capacity::shannons(500_000_000_000_000),
@@ -127,8 +127,8 @@ fn check_first_epoch_block_dao_data_calculation() {
     let parent_number = 12340;
     let epoch = EpochNumberWithFraction::new(12, 340, 1000);
     let parent_header = HeaderBuilder::default()
-        .number(parent_number)
-        .epoch(epoch)
+        .number(parent_number.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_000_123_456,
             Capacity::shannons(500_000_000_123_000),
@@ -160,8 +160,8 @@ fn check_dao_data_calculation_overflows() {
     let parent_number = 12345;
     let epoch = EpochNumberWithFraction::new(12, 345, 1000);
     let parent_header = HeaderBuilder::default()
-        .number(parent_number)
-        .epoch(epoch)
+        .number(parent_number.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_000_123_456,
             Capacity::shannons(18_446_744_073_709_000_000),
@@ -183,8 +183,8 @@ fn check_dao_data_calculation_with_transactions() {
     let parent_number = 12345;
     let epoch = EpochNumberWithFraction::new(12, 345, 1000);
     let parent_header = HeaderBuilder::default()
-        .number(parent_number)
-        .epoch(epoch)
+        .number(parent_number.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_000_123_456,
             Capacity::shannons(500_000_000_123_000),
@@ -196,16 +196,16 @@ fn check_dao_data_calculation_with_transactions() {
     let (_tmp_dir, store, parent_header) = prepare_store(&parent_header, None);
     let input_cell_data = Bytes::from("abcde");
     let input_cell = CellOutput::new_builder()
-        .capacity(capacity_bytes!(10000))
+        .capacity(capacity_bytes!(10000).pack())
         .build();
     let output_cell_data = Bytes::from("abcde12345");
     let output_cell = CellOutput::new_builder()
-        .capacity(capacity_bytes!(20000))
+        .capacity(capacity_bytes!(20000).pack())
         .build();
 
     let tx = TransactionBuilder::default()
         .output(output_cell)
-        .output_data(output_cell_data)
+        .output_data(output_cell_data.pack())
         .build();
     let rtx = ResolvedTransaction {
         transaction: tx,
@@ -235,16 +235,16 @@ fn check_dao_data_calculation_with_transactions() {
 fn check_withdraw_calculation() {
     let data = Bytes::from(vec![1; 10]);
     let output = CellOutput::new_builder()
-        .capacity(capacity_bytes!(1000000))
+        .capacity(capacity_bytes!(1000000).pack())
         .build();
     let tx = TransactionBuilder::default()
         .output(output.clone())
-        .output_data(&data)
+        .output_data(data.pack())
         .build();
     let epoch = EpochNumberWithFraction::new(1, 100, 1000);
     let deposit_header = HeaderBuilder::default()
-        .number(100)
-        .epoch(epoch)
+        .number(100.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_000_123_456,
             Default::default(),
@@ -259,8 +259,8 @@ fn check_withdraw_calculation() {
 
     let epoch = EpochNumberWithFraction::new(1, 200, 1000);
     let withdrawing_header = HeaderBuilder::default()
-        .number(200)
-        .epoch(epoch)
+        .number(200.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_001_123_456,
             Default::default(),
@@ -295,13 +295,13 @@ fn check_withdraw_calculation() {
 #[test]
 fn check_withdraw_calculation_overflows() {
     let output = CellOutput::new_builder()
-        .capacity(Capacity::shannons(18_446_744_073_709_550_000))
+        .capacity(Capacity::shannons(18_446_744_073_709_550_000).pack())
         .build();
     let tx = TransactionBuilder::default().output(output.clone()).build();
     let epoch = EpochNumberWithFraction::new(1, 100, 1000);
     let deposit_header = HeaderBuilder::default()
-        .number(100)
-        .epoch(epoch)
+        .number(100.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_000_123_456,
             Default::default(),
@@ -316,8 +316,8 @@ fn check_withdraw_calculation_overflows() {
 
     let epoch = EpochNumberWithFraction::new(1, 200, 1000);
     let withdrawing_header = HeaderBuilder::default()
-        .number(200)
-        .epoch(epoch)
+        .number(200.pack())
+        .epoch(epoch.pack())
         .dao(pack_dao_data(
             10_000_000_001_123_456,
             Default::default(),
diff --git a/util/dao/utils/src/lib.rs b/util/dao/utils/src/lib.rs
index ef2da02c14..3e67098a43 100644
--- a/util/dao/utils/src/lib.rs
+++ b/util/dao/utils/src/lib.rs
@@ -52,7 +52,7 @@ pub fn genesis_dao_data_with_satoshi_gift(
             .enumerate()
             .filter(|(index, _)| !dead_cells.contains(&OutPoint::new(tx.hash(), *index as u32)))
             .try_fold(Capacity::zero(), |capacity, (_, output)| {
-                let cap: Capacity = output.capacity().into();
+                let cap: Capacity = output.capacity().unpack();
                 capacity.safe_add(cap)
             })?;
         let u = tx
@@ -64,7 +64,7 @@ pub fn genesis_dao_data_with_satoshi_gift(
                 let occupied_capacity = if tx_index == 0
                     && output.lock().args().raw_data() == satoshi_pubkey_hash.0[..]
                 {
-                    Into::<Capacity>::into(&output.capacity())
+                    Unpack::<Capacity>::unpack(&output.capacity())
                         .safe_mul_ratio(satoshi_cell_occupied_ratio)
                 } else {
                     Capacity::bytes(data.len()).and_then(|c| output.occupied_capacity(c))
@@ -128,6 +128,7 @@ mod tests {
     pub use ckb_types::core::Capacity;
     pub use ckb_types::h256;
     pub use ckb_types::packed::Byte32;
+    pub use ckb_types::prelude::Pack;
 
     #[test]
     #[allow(clippy::unreadable_literal)]
@@ -159,7 +160,7 @@ mod tests {
             ),
         ];
         for (dao_h256, ar, c, s, u) in cases {
-            let dao_byte32: Byte32 = dao_h256.into();
+            let dao_byte32: Byte32 = dao_h256.pack();
             assert_eq!((ar, c, s, u), extract_dao_data(dao_byte32.clone()));
             assert_eq!(dao_byte32, pack_dao_data(ar, c, s, u,));
         }
diff --git a/util/fixed-hash/core/src/std_str.rs b/util/fixed-hash/core/src/std_str.rs
index 664298d50c..01ee940cc5 100644
--- a/util/fixed-hash/core/src/std_str.rs
+++ b/util/fixed-hash/core/src/std_str.rs
@@ -1,6 +1,6 @@
 use crate::{error::FromStrError, H160, H256, H512, H520};
 
-pub(crate) const DICT_HEX_ERROR: u8 = u8::MAX;
+pub(crate) const DICT_HEX_ERROR: u8 = u8::max_value();
 pub(crate) static DICT_HEX_LO: [u8; 256] = {
     const ____: u8 = DICT_HEX_ERROR;
     [
diff --git a/util/gen-types/src/conversion/blockchain/mod.rs b/util/gen-types/src/conversion/blockchain/mod.rs
index e400ed16d7..b80804fc09 100644
--- a/util/gen-types/src/conversion/blockchain/mod.rs
+++ b/util/gen-types/src/conversion/blockchain/mod.rs
@@ -9,12 +9,6 @@ impl Pack<packed::Byte32> for [u8; 32] {
     }
 }
 
-impl From<&[u8; 32]> for packed::Byte32 {
-    fn from(value: &[u8; 32]) -> Self {
-        packed::Byte32::from_slice(&value[..]).expect("impossible: fail to pack [u8; 32]")
-    }
-}
-
 impl<'r> Unpack<[u8; 32]> for packed::Byte32Reader<'r> {
     fn unpack(&self) -> [u8; 32] {
         let mut b = [0u8; 32];
@@ -24,14 +18,6 @@ impl<'r> Unpack<[u8; 32]> for packed::Byte32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!([u8; 32], Byte32);
 
-impl<'r> From<packed::Byte32Reader<'r>> for [u8; 32] {
-    fn from(value: packed::Byte32Reader<'r>) -> [u8; 32] {
-        let mut b = [0u8; 32];
-        b.copy_from_slice(value.raw_data());
-        b
-    }
-}
-
 impl Pack<packed::ProposalShortId> for [u8; 10] {
     fn pack(&self) -> packed::ProposalShortId {
         packed::ProposalShortId::from_slice(&self[..])
@@ -48,14 +34,6 @@ impl<'r> Unpack<[u8; 10]> for packed::ProposalShortIdReader<'r> {
 }
 impl_conversion_for_entity_unpack!([u8; 10], ProposalShortId);
 
-impl<'r> From<packed::ProposalShortIdReader<'r>> for [u8; 10] {
-    fn from(value: packed::ProposalShortIdReader<'r>) -> [u8; 10] {
-        let mut b = [0u8; 10];
-        b.copy_from_slice(value.raw_data());
-        b
-    }
-}
-
 impl Pack<packed::Bytes> for Bytes {
     fn pack(&self) -> packed::Bytes {
         let len = (self.len() as u32).to_le_bytes();
@@ -66,46 +44,18 @@ impl Pack<packed::Bytes> for Bytes {
     }
 }
 
-impl From<&Bytes> for packed::Bytes {
-    fn from(value: &Bytes) -> Self {
-        let len = (value.len() as u32).to_le_bytes();
-        let mut v = Vec::with_capacity(4 + value.len());
-        v.extend_from_slice(&len[..]);
-        v.extend_from_slice(&value[..]);
-        packed::Bytes::new_unchecked(v.into())
-    }
-}
-
-impl From<Bytes> for packed::Bytes {
-    fn from(value: Bytes) -> Self {
-        (&value).into()
-    }
-}
-
 impl<'r> Unpack<Bytes> for packed::BytesReader<'r> {
     fn unpack(&self) -> Bytes {
         Bytes::from(self.raw_data().to_owned())
     }
 }
 
-impl<'r> From<packed::BytesReader<'r>> for Bytes {
-    fn from(value: packed::BytesReader<'r>) -> Bytes {
-        Bytes::from(value.raw_data().to_owned())
-    }
-}
-
 impl Unpack<Bytes> for packed::Bytes {
     fn unpack(&self) -> Bytes {
         self.raw_data()
     }
 }
 
-impl From<packed::Bytes> for Bytes {
-    fn from(value: packed::Bytes) -> Bytes {
-        value.raw_data()
-    }
-}
-
 impl_conversion_for_vector!(Bytes, BytesVec, BytesVecReader);
 impl_conversion_for_packed_optional_pack!(Byte32, Byte32Opt);
 impl_conversion_for_packed_optional_pack!(CellOutput, CellOutputOpt);
@@ -120,8 +70,3 @@ impl_conversion_for_packed_iterator_pack!(CellInput, CellInputVec);
 impl_conversion_for_packed_iterator_pack!(UncleBlock, UncleBlockVec);
 impl_conversion_for_packed_iterator_pack!(Header, HeaderVec);
 impl_conversion_for_packed_iterator_pack!(Byte32, Byte32Vec);
-
-impl_conversion_for_vector_from_into!(Bytes, BytesVec, BytesVecReader);
-impl_conversion_for_packed_optional_from!(Byte32, Byte32Opt);
-impl_conversion_for_packed_optional_from!(CellOutput, CellOutputOpt);
-impl_conversion_for_packed_optional_from!(Script, ScriptOpt);
diff --git a/util/gen-types/src/conversion/blockchain/std_env.rs b/util/gen-types/src/conversion/blockchain/std_env.rs
index 696fe77123..5fd0f40751 100644
--- a/util/gen-types/src/conversion/blockchain/std_env.rs
+++ b/util/gen-types/src/conversion/blockchain/std_env.rs
@@ -10,18 +10,6 @@ impl Pack<packed::Uint64> for Capacity {
     }
 }
 
-impl From<Capacity> for packed::Uint64 {
-    fn from(value: Capacity) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&Capacity> for packed::Uint64 {
-    fn from(value: &Capacity) -> Self {
-        value.as_u64().into()
-    }
-}
-
 impl<'r> Unpack<Capacity> for packed::Uint64Reader<'r> {
     fn unpack(&self) -> Capacity {
         Capacity::shannons(self.unpack())
@@ -29,32 +17,12 @@ impl<'r> Unpack<Capacity> for packed::Uint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(Capacity, Uint64);
 
-impl<'r> From<packed::Uint64Reader<'r>> for Capacity {
-    fn from(value: packed::Uint64Reader<'r>) -> Capacity {
-        Capacity::shannons(value.into())
-    }
-}
-impl_conversion_for_entity_from!(Capacity, Uint64);
-
 impl Pack<packed::Uint256> for U256 {
     fn pack(&self) -> packed::Uint256 {
         packed::Uint256::from_slice(&self.to_le_bytes()[..]).expect("impossible: fail to pack U256")
     }
 }
 
-impl From<U256> for packed::Uint256 {
-    fn from(value: U256) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&U256> for packed::Uint256 {
-    fn from(value: &U256) -> Self {
-        packed::Uint256::from_slice(&value.to_le_bytes()[..])
-            .expect("impossible: fail to pack U256")
-    }
-}
-
 impl<'r> Unpack<U256> for packed::Uint256Reader<'r> {
     fn unpack(&self) -> U256 {
         U256::from_little_endian(self.as_slice()).expect("internal error: fail to unpack U256")
@@ -62,31 +30,12 @@ impl<'r> Unpack<U256> for packed::Uint256Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(U256, Uint256);
 
-impl<'r> From<packed::Uint256Reader<'r>> for U256 {
-    fn from(value: packed::Uint256Reader<'r>) -> U256 {
-        U256::from_little_endian(value.as_slice()).expect("internal error: fail to unpack U256")
-    }
-}
-impl_conversion_for_entity_from!(U256, Uint256);
-
 impl Pack<packed::Byte32> for H256 {
     fn pack(&self) -> packed::Byte32 {
         packed::Byte32::from_slice(self.as_bytes()).expect("impossible: fail to pack H256")
     }
 }
 
-impl From<H256> for packed::Byte32 {
-    fn from(value: H256) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&H256> for packed::Byte32 {
-    fn from(value: &H256) -> Self {
-        packed::Byte32::from_slice(value.as_bytes()).expect("impossible: fail to pack H256")
-    }
-}
-
 impl<'r> Unpack<H256> for packed::Byte32Reader<'r> {
     fn unpack(&self) -> H256 {
         H256::from_slice(self.as_slice()).expect("internal error: fail to unpack H256")
@@ -94,15 +43,5 @@ impl<'r> Unpack<H256> for packed::Byte32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(H256, Byte32);
 
-impl<'r> From<packed::Byte32Reader<'r>> for H256 {
-    fn from(value: packed::Byte32Reader<'r>) -> H256 {
-        H256::from_slice(value.as_slice()).expect("internal error: fail to unpack H256")
-    }
-}
-impl_conversion_for_entity_from!(H256, Byte32);
-
 impl_conversion_for_option!(H256, Byte32Opt, Byte32OptReader);
 impl_conversion_for_vector!(Capacity, Uint64Vec, Uint64VecReader);
-
-impl_conversion_for_option_from_into!(H256, Byte32Opt, Byte32OptReader, Byte32);
-impl_conversion_for_vector_from_into!(Capacity, Uint64Vec, Uint64VecReader);
diff --git a/util/gen-types/src/conversion/primitive.rs b/util/gen-types/src/conversion/primitive.rs
index b0a326abe8..38d82d9228 100644
--- a/util/gen-types/src/conversion/primitive.rs
+++ b/util/gen-types/src/conversion/primitive.rs
@@ -1,6 +1,5 @@
 #[cfg(not(feature = "std"))]
 use alloc::{borrow::ToOwned, str, string::String};
-use core::usize;
 #[cfg(feature = "std")]
 use std::str;
 
@@ -13,29 +12,6 @@ impl Pack<packed::Bool> for bool {
     }
 }
 
-impl From<bool> for packed::Bool {
-    fn from(value: bool) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&bool> for packed::Bool {
-    fn from(value: &bool) -> Self {
-        let b = u8::from(*value);
-        packed::Bool::new_unchecked(Bytes::from(vec![b]))
-    }
-}
-
-impl<'r> From<packed::BoolReader<'r>> for bool {
-    fn from(value: packed::BoolReader<'r>) -> bool {
-        match value.as_slice()[0] {
-            0 => false,
-            1 => true,
-            _ => unreachable!(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(bool, Bool);
 impl<'r> Unpack<bool> for packed::BoolReader<'r> {
     fn unpack(&self) -> bool {
         match self.as_slice()[0] {
@@ -53,80 +29,24 @@ impl Pack<packed::Uint32> for u32 {
     }
 }
 
-impl From<u32> for packed::Uint32 {
-    fn from(value: u32) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&u32> for packed::Uint32 {
-    fn from(value: &u32) -> Self {
-        packed::Uint32::new_unchecked(Bytes::from(value.to_le_bytes().to_vec()))
-    }
-}
-
 impl Pack<packed::Uint64> for u64 {
     fn pack(&self) -> packed::Uint64 {
         packed::Uint64::new_unchecked(Bytes::from(self.to_le_bytes().to_vec()))
     }
 }
 
-impl From<u64> for packed::Uint64 {
-    fn from(value: u64) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&u64> for packed::Uint64 {
-    fn from(value: &u64) -> Self {
-        packed::Uint64::new_unchecked(Bytes::from(value.to_le_bytes().to_vec()))
-    }
-}
-
 impl Pack<packed::Uint128> for u128 {
     fn pack(&self) -> packed::Uint128 {
         packed::Uint128::new_unchecked(Bytes::from(self.to_le_bytes().to_vec()))
     }
 }
 
-impl From<u128> for packed::Uint128 {
-    fn from(value: u128) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&u128> for packed::Uint128 {
-    fn from(value: &u128) -> Self {
-        packed::Uint128::new_unchecked(Bytes::from(value.to_le_bytes().to_vec()))
-    }
-}
-
 impl Pack<packed::Uint32> for usize {
     fn pack(&self) -> packed::Uint32 {
         (*self as u32).pack()
     }
 }
 
-impl From<usize> for packed::Uint32 {
-    fn from(value: usize) -> Self {
-        (value as u32).into()
-    }
-}
-
-impl From<&usize> for packed::Uint32 {
-    fn from(value: &usize) -> Self {
-        (*value as u32).into()
-    }
-}
-
-impl<'r> From<packed::Uint32Reader<'r>> for u32 {
-    fn from(value: packed::Uint32Reader<'r>) -> u32 {
-        let mut b = [0u8; 4];
-        b.copy_from_slice(value.as_slice());
-        u32::from_le_bytes(b)
-    }
-}
-impl_conversion_for_entity_from!(u32, Uint32);
 impl<'r> Unpack<u32> for packed::Uint32Reader<'r> {
     fn unpack(&self) -> u32 {
         let mut b = [0u8; 4];
@@ -136,14 +56,6 @@ impl<'r> Unpack<u32> for packed::Uint32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u32, Uint32);
 
-impl<'r> From<packed::Uint64Reader<'r>> for u64 {
-    fn from(value: packed::Uint64Reader<'r>) -> u64 {
-        let mut b = [0u8; 8];
-        b.copy_from_slice(value.as_slice());
-        u64::from_le_bytes(b)
-    }
-}
-impl_conversion_for_entity_from!(u64, Uint64);
 impl<'r> Unpack<u64> for packed::Uint64Reader<'r> {
     fn unpack(&self) -> u64 {
         let mut b = [0u8; 8];
@@ -153,14 +65,6 @@ impl<'r> Unpack<u64> for packed::Uint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u64, Uint64);
 
-impl<'r> From<packed::Uint128Reader<'r>> for u128 {
-    fn from(value: packed::Uint128Reader<'r>) -> u128 {
-        let mut b = [0u8; 16];
-        b.copy_from_slice(value.as_slice());
-        u128::from_le_bytes(b)
-    }
-}
-impl_conversion_for_entity_from!(u128, Uint128);
 impl<'r> Unpack<u128> for packed::Uint128Reader<'r> {
     fn unpack(&self) -> u128 {
         let mut b = [0u8; 16];
@@ -170,13 +74,6 @@ impl<'r> Unpack<u128> for packed::Uint128Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u128, Uint128);
 
-impl<'r> From<packed::Uint32Reader<'r>> for usize {
-    fn from(value: packed::Uint32Reader<'r>) -> usize {
-        let x: u32 = value.into();
-        x as usize
-    }
-}
-impl_conversion_for_entity_from!(usize, Uint32);
 impl<'r> Unpack<usize> for packed::Uint32Reader<'r> {
     fn unpack(&self) -> usize {
         let x: u32 = self.unpack();
@@ -191,62 +88,18 @@ impl Pack<packed::BeUint32> for u32 {
     }
 }
 
-impl From<u32> for packed::BeUint32 {
-    fn from(value: u32) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&u32> for packed::BeUint32 {
-    fn from(value: &u32) -> Self {
-        packed::BeUint32::new_unchecked(Bytes::from(value.to_be_bytes().to_vec()))
-    }
-}
-
 impl Pack<packed::BeUint64> for u64 {
     fn pack(&self) -> packed::BeUint64 {
         packed::BeUint64::new_unchecked(Bytes::from(self.to_be_bytes().to_vec()))
     }
 }
 
-impl From<u64> for packed::BeUint64 {
-    fn from(value: u64) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&u64> for packed::BeUint64 {
-    fn from(value: &u64) -> Self {
-        packed::BeUint64::new_unchecked(Bytes::from(value.to_be_bytes().to_vec()))
-    }
-}
-
 impl Pack<packed::BeUint32> for usize {
     fn pack(&self) -> packed::BeUint32 {
         (*self as u32).pack()
     }
 }
 
-impl From<usize> for packed::BeUint32 {
-    fn from(value: usize) -> Self {
-        (value as u32).into()
-    }
-}
-
-impl From<&usize> for packed::BeUint32 {
-    fn from(value: &usize) -> Self {
-        (*value as u32).into()
-    }
-}
-
-impl<'r> From<packed::BeUint32Reader<'r>> for u32 {
-    fn from(value: packed::BeUint32Reader<'r>) -> u32 {
-        let mut b = [0u8; 4];
-        b.copy_from_slice(value.as_slice());
-        u32::from_be_bytes(b)
-    }
-}
-impl_conversion_for_entity_from!(u32, BeUint32);
 impl<'r> Unpack<u32> for packed::BeUint32Reader<'r> {
     fn unpack(&self) -> u32 {
         let mut b = [0u8; 4];
@@ -256,14 +109,6 @@ impl<'r> Unpack<u32> for packed::BeUint32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u32, BeUint32);
 
-impl<'r> From<packed::BeUint64Reader<'r>> for u64 {
-    fn from(value: packed::BeUint64Reader<'r>) -> u64 {
-        let mut b = [0u8; 8];
-        b.copy_from_slice(value.as_slice());
-        u64::from_be_bytes(b)
-    }
-}
-impl_conversion_for_entity_from!(u64, BeUint64);
 impl<'r> Unpack<u64> for packed::BeUint64Reader<'r> {
     fn unpack(&self) -> u64 {
         let mut b = [0u8; 8];
@@ -273,13 +118,6 @@ impl<'r> Unpack<u64> for packed::BeUint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u64, BeUint64);
 
-impl<'r> From<packed::BeUint32Reader<'r>> for usize {
-    fn from(value: packed::BeUint32Reader<'r>) -> usize {
-        let x: u32 = value.into();
-        x as usize
-    }
-}
-impl_conversion_for_entity_from!(usize, BeUint32);
 impl<'r> Unpack<usize> for packed::BeUint32Reader<'r> {
     fn unpack(&self) -> usize {
         let x: u32 = self.unpack();
@@ -298,34 +136,6 @@ impl Pack<packed::Bytes> for [u8] {
     }
 }
 
-impl From<&[u8]> for packed::Bytes {
-    fn from(value: &[u8]) -> Self {
-        let len = value.len();
-        let mut vec: Vec<u8> = Vec::with_capacity(4 + len);
-        vec.extend_from_slice(&(len as u32).to_le_bytes()[..]);
-        vec.extend_from_slice(value);
-        packed::Bytes::new_unchecked(Bytes::from(vec))
-    }
-}
-
-impl<const N: usize> From<[u8; N]> for packed::Bytes {
-    fn from(value: [u8; N]) -> Self {
-        (&value[..]).into()
-    }
-}
-
-impl<const N: usize> From<&[u8; N]> for packed::Bytes {
-    fn from(value: &[u8; N]) -> Self {
-        (&value[..]).into()
-    }
-}
-
-impl<'r> From<packed::BytesReader<'r>> for Vec<u8> {
-    fn from(value: packed::BytesReader<'r>) -> Vec<u8> {
-        value.raw_data().to_owned()
-    }
-}
-impl_conversion_for_entity_from!(Vec<u8>, Bytes);
 impl<'r> Unpack<Vec<u8>> for packed::BytesReader<'r> {
     fn unpack(&self) -> Vec<u8> {
         self.raw_data().to_owned()
@@ -339,12 +149,6 @@ impl Pack<packed::Bytes> for str {
     }
 }
 
-impl From<&str> for packed::Bytes {
-    fn from(value: &str) -> Self {
-        value.as_bytes().into()
-    }
-}
-
 impl<'r> packed::BytesReader<'r> {
     /// Converts self to a string slice.
     pub fn as_utf8(&self) -> Result<&str, str::Utf8Error> {
@@ -374,24 +178,12 @@ impl Pack<packed::Bytes> for String {
     }
 }
 
-impl From<String> for packed::Bytes {
-    fn from(value: String) -> Self {
-        value.as_str().into()
-    }
-}
-
 impl<'r> Unpack<Option<Vec<u64>>> for packed::Uint64VecOptReader<'r> {
     fn unpack(&self) -> Option<Vec<u64>> {
         self.to_opt().map(|x| x.unpack())
     }
 }
 
-impl<'r> From<packed::Uint64VecOptReader<'r>> for Option<Vec<u64>> {
-    fn from(value: packed::Uint64VecOptReader<'r>) -> Option<Vec<u64>> {
-        value.to_opt().map(|x| x.into())
-    }
-}
-
 impl_conversion_for_entity_unpack!(Option<Vec<u64>>, Uint64VecOpt);
 
 impl Pack<packed::Uint64VecOpt> for Option<Vec<u64>> {
@@ -406,24 +198,6 @@ impl Pack<packed::Uint64VecOpt> for Option<Vec<u64>> {
     }
 }
 
-impl From<Option<Vec<u64>>> for packed::Uint64VecOpt {
-    fn from(value: Option<Vec<u64>>) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&Option<Vec<u64>>> for packed::Uint64VecOpt {
-    fn from(value: &Option<Vec<u64>>) -> Self {
-        if let Some(inner) = value {
-            packed::Uint64VecOptBuilder::default()
-                .set(Some(inner.as_slice().into()))
-                .build()
-        } else {
-            packed::Uint64VecOpt::default()
-        }
-    }
-}
-
 impl_conversion_for_option!(bool, BoolOpt, BoolOptReader);
 impl_conversion_for_vector!(u32, Uint32Vec, Uint32VecReader);
 impl_conversion_for_vector!(usize, Uint32Vec, Uint32VecReader);
@@ -432,13 +206,3 @@ impl_conversion_for_option_pack!(&str, BytesOpt);
 impl_conversion_for_option_pack!(String, BytesOpt);
 impl_conversion_for_option_pack!(Bytes, BytesOpt);
 impl_conversion_for_packed_optional_pack!(Bytes, BytesOpt);
-
-impl_conversion_for_option_from_into!(bool, BoolOpt, BoolOptReader, Bool);
-impl_conversion_for_vector_from_into!(u32, Uint32Vec, Uint32VecReader);
-impl_conversion_for_vector_from_into!(usize, Uint32Vec, Uint32VecReader);
-impl_conversion_for_vector_from_into!(u64, Uint64Vec, Uint64VecReader);
-
-impl_conversion_for_option_from!(&str, BytesOpt, Bytes);
-impl_conversion_for_option_from!(String, BytesOpt, Bytes);
-impl_conversion_for_option_from!(Bytes, BytesOpt, Bytes);
-impl_conversion_for_packed_optional_from!(Bytes, BytesOpt);
diff --git a/util/gen-types/src/conversion/utilities.rs b/util/gen-types/src/conversion/utilities.rs
index 2109c79bff..cd5faa9a78 100644
--- a/util/gen-types/src/conversion/utilities.rs
+++ b/util/gen-types/src/conversion/utilities.rs
@@ -8,22 +8,6 @@ macro_rules! impl_conversion_for_entity_unpack {
     };
 }
 
-macro_rules! impl_conversion_for_entity_from {
-    ($original:ty, $entity:ident) => {
-        impl From<packed::$entity> for $original {
-            fn from(v: packed::$entity) -> $original {
-                (&v).into()
-            }
-        }
-
-        impl From<&packed::$entity> for $original {
-            fn from(v: &packed::$entity) -> $original {
-                v.as_reader().into()
-            }
-        }
-    };
-}
-
 macro_rules! impl_conversion_for_option_pack {
     ($original:ty, $entity:ident) => {
         impl Pack<packed::$entity> for Option<$original> {
@@ -38,22 +22,6 @@ macro_rules! impl_conversion_for_option_pack {
     };
 }
 
-macro_rules! impl_conversion_for_option_from {
-    ($original:ty, $entity:ident, $entity_inner:ident) => {
-        impl From<Option<$original>> for packed::$entity {
-            fn from(value: Option<$original>) -> packed::$entity {
-                if let Some(inner) = value {
-                    packed::$entity::new_unchecked(
-                        Into::<packed::$entity_inner>::into(inner).as_bytes(),
-                    )
-                } else {
-                    packed::$entity::default()
-                }
-            }
-        }
-    };
-}
-
 macro_rules! impl_conversion_for_option_unpack {
     ($original:ty, $entity:ident, $reader:ident) => {
         impl<'r> Unpack<Option<$original>> for packed::$reader<'r> {
@@ -65,17 +33,6 @@ macro_rules! impl_conversion_for_option_unpack {
     };
 }
 
-macro_rules! impl_conversion_for_option_reader_from {
-    ($original:ty, $entity:ident, $reader:ident) => {
-        impl<'r> From<packed::$reader<'r>> for Option<$original> {
-            fn from(value: packed::$reader<'r>) -> Option<$original> {
-                value.to_opt().map(|x| x.into())
-            }
-        }
-        impl_conversion_for_entity_from!(Option<$original>, $entity);
-    };
-}
-
 macro_rules! impl_conversion_for_option {
     ($original:ty, $entity:ident, $reader:ident) => {
         impl_conversion_for_option_pack!($original, $entity);
@@ -83,13 +40,6 @@ macro_rules! impl_conversion_for_option {
     };
 }
 
-macro_rules! impl_conversion_for_option_from_into {
-    ($original:ty, $entity:ident, $reader:ident, $entity_inner:ident) => {
-        impl_conversion_for_option_from!($original, $entity, $entity_inner);
-        impl_conversion_for_option_reader_from!($original, $entity, $reader);
-    };
-}
-
 macro_rules! impl_conversion_for_vector_pack {
     ($original:ty, $entity:ident) => {
         impl Pack<packed::$entity> for [$original] {
@@ -102,30 +52,6 @@ macro_rules! impl_conversion_for_vector_pack {
     };
 }
 
-macro_rules! impl_conversion_for_vector_from {
-    ($original:ty, $entity:ident) => {
-        impl From<&[$original]> for packed::$entity {
-            fn from(value: &[$original]) -> packed::$entity {
-                packed::$entity::new_builder()
-                    .set(value.iter().map(|v| v.into()).collect())
-                    .build()
-            }
-        }
-
-        impl<const N: usize> From<[$original; N]> for packed::$entity {
-            fn from(value: [$original; N]) -> packed::$entity {
-                (&value[..]).into()
-            }
-        }
-
-        impl<const N: usize> From<&[$original; N]> for packed::$entity {
-            fn from(value: &[$original; N]) -> packed::$entity {
-                (&value[..]).into()
-            }
-        }
-    };
-}
-
 macro_rules! impl_conversion_for_vector_unpack {
     ($original:ty, $entity:ident, $reader:ident) => {
         impl<'r> Unpack<Vec<$original>> for packed::$reader<'r> {
@@ -137,17 +63,6 @@ macro_rules! impl_conversion_for_vector_unpack {
     };
 }
 
-macro_rules! impl_conversion_for_vector_reader_from {
-    ($original:ty, $entity:ident, $reader:ident) => {
-        impl<'r> From<packed::$reader<'r>> for Vec<$original> {
-            fn from(value: packed::$reader<'r>) -> Vec<$original> {
-                value.iter().map(|x| x.into()).collect()
-            }
-        }
-        impl_conversion_for_entity_from!(Vec<$original>, $entity);
-    };
-}
-
 macro_rules! impl_conversion_for_vector {
     ($original:ty, $entity:ident, $reader:ident) => {
         impl_conversion_for_vector_pack!($original, $entity);
@@ -155,13 +70,6 @@ macro_rules! impl_conversion_for_vector {
     };
 }
 
-macro_rules! impl_conversion_for_vector_from_into {
-    ($original:ty, $entity:ident, $reader:ident) => {
-        impl_conversion_for_vector_from!($original, $entity);
-        impl_conversion_for_vector_reader_from!($original, $entity, $reader);
-    };
-}
-
 macro_rules! impl_conversion_for_packed_optional_pack {
     ($original:ident, $entity:ident) => {
         impl Pack<packed::$entity> for Option<packed::$original> {
@@ -176,20 +84,6 @@ macro_rules! impl_conversion_for_packed_optional_pack {
     };
 }
 
-macro_rules! impl_conversion_for_packed_optional_from {
-    ($original:ident, $entity:ident) => {
-        impl From<Option<packed::$original>> for packed::$entity {
-            fn from(value: Option<packed::$original>) -> packed::$entity {
-                if let Some(ref inner) = value {
-                    packed::$entity::new_unchecked(inner.as_bytes())
-                } else {
-                    packed::$entity::default()
-                }
-            }
-        }
-    };
-}
-
 macro_rules! impl_conversion_for_packed_iterator_pack {
     ($item:ident, $vec:ident) => {
         impl<T> PackVec<packed::$vec, packed::$item> for T
diff --git a/util/gen-types/src/extension/calc_hash.rs b/util/gen-types/src/extension/calc_hash.rs
index ff0b5a2e1c..b552ca7e20 100644
--- a/util/gen-types/src/extension/calc_hash.rs
+++ b/util/gen-types/src/extension/calc_hash.rs
@@ -17,7 +17,7 @@ where
     R: Reader<'r>,
 {
     fn calc_hash(&self) -> packed::Byte32 {
-        blake2b_256(self.as_slice()).into()
+        blake2b_256(self.as_slice()).pack()
     }
 }
 
@@ -65,7 +65,7 @@ impl packed::CellOutput {
         if data.is_empty() {
             packed::Byte32::zero()
         } else {
-            blake2b_256(data).into()
+            blake2b_256(data).pack()
         }
     }
 }
@@ -75,7 +75,7 @@ impl<'r> packed::BytesReader<'r> {
     ///
     /// Returns the empty hash if no data, otherwise, calculates the hash of the data and returns it.
     pub fn calc_raw_data_hash(&self) -> packed::Byte32 {
-        blake2b_256(self.raw_data()).into()
+        blake2b_256(self.raw_data()).pack()
     }
 }
 impl_calc_special_hash_for_entity!(Bytes, calc_raw_data_hash);
@@ -116,7 +116,7 @@ impl<'r> packed::ProposalShortIdVecReader<'r> {
                 blake2b.update(id.as_slice());
             }
             blake2b.finalize(&mut ret);
-            ret.into()
+            ret.pack()
         }
     }
 }
@@ -215,7 +215,7 @@ impl<'r> packed::UncleBlockVecReader<'r> {
                 blake2b.update(uncle.calc_header_hash().as_slice());
             }
             blake2b.finalize(&mut ret);
-            ret.into()
+            ret.pack()
         }
     }
 }
diff --git a/util/gen-types/src/extension/capacity.rs b/util/gen-types/src/extension/capacity.rs
index 3970406295..ac4478378f 100644
--- a/util/gen-types/src/extension/capacity.rs
+++ b/util/gen-types/src/extension/capacity.rs
@@ -46,7 +46,7 @@ impl packed::CellOutput {
     /// [`occupied capacity`]: #method.occupied_capacity
     pub fn is_lack_of_capacity(&self, data_capacity: Capacity) -> CapacityResult<bool> {
         self.occupied_capacity(data_capacity)
-            .map(|cap| cap > self.capacity().into())
+            .map(|cap| cap > self.capacity().unpack())
     }
 }
 
@@ -71,7 +71,7 @@ impl packed::CellOutputBuilder {
                     .transpose()
                     .and_then(|y| y.unwrap_or_else(Capacity::zero).safe_add(x))
             })
-            .map(|x| self.capacity(x).build())
+            .map(|x| self.capacity(x.pack()).build())
     }
 }
 
@@ -83,7 +83,7 @@ impl packed::CellOutputVec {
         self.as_reader()
             .iter()
             .map(|output| {
-                let cap: Capacity = output.capacity().into();
+                let cap: Capacity = output.capacity().unpack();
                 cap
             })
             .try_fold(Capacity::zero(), Capacity::safe_add)
diff --git a/util/gen-types/src/extension/rust_core_traits.rs b/util/gen-types/src/extension/rust_core_traits.rs
index 631224abdb..792895cf93 100644
--- a/util/gen-types/src/extension/rust_core_traits.rs
+++ b/util/gen-types/src/extension/rust_core_traits.rs
@@ -52,8 +52,8 @@ macro_rules! impl_cmp_partial_ord {
 impl ::core::cmp::Ord for packed::Uint32 {
     #[inline]
     fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
-        let self_val: u32 = self.as_reader().into();
-        let other_val: u32 = other.as_reader().into();
+        let self_val: u32 = self.unpack();
+        let other_val: u32 = other.unpack();
         self_val.cmp(&other_val)
     }
 }
@@ -62,8 +62,8 @@ impl_cmp_partial_ord!(Uint32);
 impl ::core::cmp::Ord for packed::Uint64 {
     #[inline]
     fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
-        let self_val: u64 = self.as_reader().into();
-        let other_val: u64 = other.as_reader().into();
+        let self_val: u64 = self.unpack();
+        let other_val: u64 = other.unpack();
         self_val.cmp(&other_val)
     }
 }
@@ -72,8 +72,8 @@ impl_cmp_partial_ord!(Uint64);
 impl ::core::cmp::Ord for packed::Uint128 {
     #[inline]
     fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
-        let self_val: u128 = self.as_reader().into();
-        let other_val: u128 = other.as_reader().into();
+        let self_val: u128 = self.unpack();
+        let other_val: u128 = other.unpack();
         self_val.cmp(&other_val)
     }
 }
@@ -81,14 +81,14 @@ impl_cmp_partial_ord!(Uint128);
 
 #[cfg(feature = "std")]
 mod std_feature_mod {
-    use crate::packed;
+    use crate::{packed, prelude::*};
     use numext_fixed_uint::U256;
 
     impl ::core::cmp::Ord for packed::Uint256 {
         #[inline]
         fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
-            let self_val: U256 = self.as_reader().into();
-            let other_val: U256 = other.as_reader().into();
+            let self_val: U256 = self.unpack();
+            let other_val: U256 = other.unpack();
             self_val.cmp(&other_val)
         }
     }
diff --git a/util/gen-types/src/extension/shortcut.rs b/util/gen-types/src/extension/shortcut.rs
index b10f9e68cd..499145ee90 100644
--- a/util/gen-types/src/extension/shortcut.rs
+++ b/util/gen-types/src/extension/shortcut.rs
@@ -10,7 +10,7 @@ impl packed::Byte32 {
 
     /// Creates a new `Byte32` whose bits are all ones.
     pub fn max_value() -> Self {
-        [u8::max_value(); 32].into()
+        [u8::max_value(); 32].pack()
     }
 
     /// Checks whether all bits in self are zeros.
@@ -20,7 +20,7 @@ impl packed::Byte32 {
 
     /// Creates a new `Bytes32`.
     pub fn new(v: [u8; 32]) -> Self {
-        v.into()
+        v.pack()
     }
 }
 
@@ -29,7 +29,7 @@ impl packed::ProposalShortId {
     pub fn from_tx_hash(h: &packed::Byte32) -> Self {
         let mut inner = [0u8; 10];
         inner.copy_from_slice(&h.as_slice()[..10]);
-        inner.into()
+        inner.pack()
     }
 
     /// Creates a new `ProposalShortId` whose bits are all zeros.
@@ -39,7 +39,7 @@ impl packed::ProposalShortId {
 
     /// Creates a new `ProposalShortId`.
     pub fn new(v: [u8; 10]) -> Self {
-        v.into()
+        v.pack()
     }
 }
 
@@ -48,20 +48,20 @@ impl packed::OutPoint {
     pub fn new(tx_hash: packed::Byte32, index: u32) -> Self {
         packed::OutPoint::new_builder()
             .tx_hash(tx_hash)
-            .index(index)
+            .index(index.pack())
             .build()
     }
 
     /// Creates a new null `OutPoint`.
     pub fn null() -> Self {
         packed::OutPoint::new_builder()
-            .index(u32::max_value())
+            .index(u32::max_value().pack())
             .build()
     }
 
     /// Checks whether self is a null `OutPoint`.
     pub fn is_null(&self) -> bool {
-        self.tx_hash().is_zero() && Into::<u32>::into(self.index().as_reader()) == u32::max_value()
+        self.tx_hash().is_zero() && Unpack::<u32>::unpack(&self.index()) == u32::max_value()
     }
 
     /// Generates a binary data to be used as a key for indexing cells in storage.
@@ -82,7 +82,7 @@ impl packed::OutPoint {
     ///   order, so as to traverse cells in the forward order too.
     pub fn to_cell_key(&self) -> Vec<u8> {
         let mut key = Vec::with_capacity(36);
-        let index: u32 = self.index().as_reader().into();
+        let index: u32 = self.index().unpack();
         key.extend_from_slice(self.tx_hash().as_slice());
         key.extend_from_slice(&index.to_be_bytes());
         key
@@ -93,7 +93,7 @@ impl packed::CellInput {
     /// Creates a new `CellInput`.
     pub fn new(previous_output: packed::OutPoint, block_number: BlockNumber) -> Self {
         packed::CellInput::new_builder()
-            .since(block_number)
+            .since(block_number.pack())
             .previous_output(previous_output)
             .build()
     }
@@ -110,7 +110,7 @@ impl packed::Script {
             .lock(self)
             .build()
             .as_bytes()
-            .into()
+            .pack()
     }
 
     /// Converts from bytes of [`CellbaseWitness`](struct.CellbaseWitness.html).
diff --git a/util/gen-types/src/extension/tests/calc_hash.rs b/util/gen-types/src/extension/tests/calc_hash.rs
index e828d9b512..b0715dd1ec 100644
--- a/util/gen-types/src/extension/tests/calc_hash.rs
+++ b/util/gen-types/src/extension/tests/calc_hash.rs
@@ -1,108 +1,100 @@
-use crate::{
-    packed::{self, ProposalShortIdVec, UncleBlockVec},
-    prelude::*,
-    vec,
-};
+use crate::{packed, prelude::*, vec};
 use ckb_fixed_hash::h256;
 use ckb_hash::blake2b_256;
 
 #[test]
 fn proposals_hash() {
-    let proposal1 = [1; 10].into();
-    let proposal2 = [2; 10].into();
-    let proposals: ProposalShortIdVec = vec![proposal1, proposal2].into();
+    let proposal1 = [1; 10].pack();
+    let proposal2 = [2; 10].pack();
+    let proposals = vec![proposal1, proposal2].pack();
     let expect = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562");
-    assert_eq!(proposals.calc_proposals_hash(), expect.into());
+    assert_eq!(proposals.calc_proposals_hash(), expect.pack());
 }
 
 #[test]
 fn empty_proposals_hash() {
     let proposals = packed::ProposalShortIdVec::new_builder().build();
     let expect = h256!("0x0");
-    assert_eq!(proposals.calc_proposals_hash(), expect.into());
+    assert_eq!(proposals.calc_proposals_hash(), expect.pack());
 }
 
 #[test]
 fn uncles_hash() {
     let uncle1_raw_header = packed::RawHeader::new_builder()
-        .version(0u32)
-        .compact_target(0x1e08_3126u32)
-        .timestamp(0x5cd2_b117u64)
-        .number(0x400u64)
-        .epoch(0x0007_0800_1800_0001u64)
-        .parent_hash(h256!(
-            "0x8381df265c9442d5c27559b167892c5a6a8322871112d3cc8ef45222c6624831"
-        ))
-        .transactions_root(h256!(
-            "0x12214693b8bd5c3d8f96e270dc8fe32b1702bd97630a9eab53a69793e6bc893f"
-        ))
-        .proposals_hash(h256!(
-            "0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
-        ))
-        .extra_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .dao(h256!(
-            "0xb54bdd7f6be90000bb52f392d41cd70024f7ef29b437000000febffacf030000"
-        ))
+        .version(0u32.pack())
+        .compact_target(0x1e08_3126u32.pack())
+        .timestamp(0x5cd2_b117u64.pack())
+        .number(0x400u64.pack())
+        .epoch(0x0007_0800_1800_0001u64.pack())
+        .parent_hash(
+            h256!("0x8381df265c9442d5c27559b167892c5a6a8322871112d3cc8ef45222c6624831").pack(),
+        )
+        .transactions_root(
+            h256!("0x12214693b8bd5c3d8f96e270dc8fe32b1702bd97630a9eab53a69793e6bc893f").pack(),
+        )
+        .proposals_hash(
+            h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack(),
+        )
+        .extra_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .dao(h256!("0xb54bdd7f6be90000bb52f392d41cd70024f7ef29b437000000febffacf030000").pack())
         .build();
     let uncle1_header = packed::Header::new_builder()
         .raw(uncle1_raw_header)
-        .nonce(0x5ff1_389a_f870_6543_11a2_bee6_1237u128)
+        .nonce(0x5ff1_389a_f870_6543_11a2_bee6_1237u128.pack())
         .build();
-    let uncle1_proposals: ProposalShortIdVec = vec![[1; 10].into(), [2; 10].into()].into();
+    let uncle1_proposals = vec![[1; 10].pack(), [2; 10].pack()].pack();
     let uncle1 = packed::UncleBlock::new_builder()
         .header(uncle1_header)
         .proposals(uncle1_proposals)
         .build();
 
     let uncle2_raw_header = packed::RawHeader::new_builder()
-        .version(0u32)
-        .compact_target(0x2001_0000u32)
-        .timestamp(0x5cd2_1a16u64)
-        .number(0x400u64)
-        .epoch(0x0007_0800_1800_0001u64)
-        .parent_hash(h256!(
-            "0x8381df265c9442d5c27559b167892c5a6a8322871112d3cc8ef45222c6624831"
-        ))
-        .transactions_root(h256!(
-            "0x12214693b8bd5c3d8f96e270dc8fe32b1702bd97630a9eab53a69793e6bc893f"
-        ))
-        .proposals_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .extra_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .dao(h256!(
-            "0xb54bdd7f6be90000bb52f392d41cd70024f7ef29b437000000febffacf030000"
-        ))
+        .version(0u32.pack())
+        .compact_target(0x2001_0000u32.pack())
+        .timestamp(0x5cd2_1a16u64.pack())
+        .number(0x400u64.pack())
+        .epoch(0x0007_0800_1800_0001u64.pack())
+        .parent_hash(
+            h256!("0x8381df265c9442d5c27559b167892c5a6a8322871112d3cc8ef45222c6624831").pack(),
+        )
+        .transactions_root(
+            h256!("0x12214693b8bd5c3d8f96e270dc8fe32b1702bd97630a9eab53a69793e6bc893f").pack(),
+        )
+        .proposals_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .extra_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .dao(h256!("0xb54bdd7f6be90000bb52f392d41cd70024f7ef29b437000000febffacf030000").pack())
         .build();
     let uncle2_header = packed::Header::new_builder()
         .raw(uncle2_raw_header)
-        .nonce(0x2f39_2d41_cd70_024fu128)
+        .nonce(0x2f39_2d41_cd70_024fu128.pack())
         .build();
     let uncle2 = packed::UncleBlock::new_builder()
         .header(uncle2_header)
         .build();
 
-    let uncles: UncleBlockVec = vec![uncle1, uncle2].into();
+    let uncles = vec![uncle1, uncle2].pack();
     let expect = h256!("0x0135d01f169a870bd9c92b2b37aecfa0fbfb7c1862cc176e03bb525fab0649d9");
-    assert_eq!(uncles.calc_uncles_hash(), expect.into());
+    assert_eq!(uncles.calc_uncles_hash(), expect.pack());
 }
 
 #[test]
 fn empty_uncles_hash() {
     let uncles = packed::UncleBlockVec::new_builder().build();
     let expect = h256!("0x0");
-    assert_eq!(uncles.calc_uncles_hash(), expect.into());
+    assert_eq!(uncles.calc_uncles_hash(), expect.pack());
 }
 
 #[test]
 fn empty_script_hash() {
     let script = packed::Script::new_builder().build();
     let expect = h256!("0x77c93b0632b5b6c3ef922c5b7cea208fb0a7c427a13d50e13d3fefad17e0c590");
-    assert_eq!(script.calc_script_hash(), expect.into());
+    assert_eq!(script.calc_script_hash(), expect.pack());
 }
 
 #[test]
@@ -111,15 +103,15 @@ fn always_success_script_hash() {
     let always_success_hash = blake2b_256(&always_success[..]);
 
     let script = packed::Script::new_builder()
-        .code_hash(always_success_hash)
+        .code_hash(always_success_hash.pack())
         .build();
     let expect = h256!("0x4ceaa32f692948413e213ce6f3a83337145bde6e11fd8cb94377ce2637dcc412");
-    assert_eq!(script.calc_script_hash(), expect.into());
+    assert_eq!(script.calc_script_hash(), expect.pack());
 }
 
 #[test]
 fn one_arg_script_hash() {
-    let script = packed::Script::new_builder().args([1]).build();
+    let script = packed::Script::new_builder().args([1].pack()).build();
     let expect = h256!("0x67951b34bce20cb71b7e235c1f8cda259628d99d94825bffe549c23b4dd2930f");
-    assert_eq!(script.calc_script_hash(), expect.into());
+    assert_eq!(script.calc_script_hash(), expect.pack());
 }
diff --git a/util/gen-types/src/extension/tests/capacity.rs b/util/gen-types/src/extension/tests/capacity.rs
index 223bbbb06b..3502bf6a0b 100644
--- a/util/gen-types/src/extension/tests/capacity.rs
+++ b/util/gen-types/src/extension/tests/capacity.rs
@@ -10,7 +10,7 @@ fn script_occupied_capacity() {
         (vec![0, 0], 2 + 32 + 1),
     ];
     for (args, ckb) in testcases.into_iter() {
-        let script = packed::Script::new_builder().args(args).build();
+        let script = packed::Script::new_builder().args(args.pack()).build();
         let expect = Capacity::bytes(ckb).unwrap();
         assert_eq!(script.occupied_capacity().unwrap(), expect);
     }
@@ -28,7 +28,7 @@ fn min_cell_output_capacity() {
 
 #[test]
 fn min_secp256k1_cell_output_capacity() {
-    let lock = packed::Script::new_builder().args([0u8; 20]).build();
+    let lock = packed::Script::new_builder().args([0u8; 20].pack()).build();
     let output = packed::CellOutput::new_builder().lock(lock).build();
     assert_eq!(
         output.occupied_capacity(Capacity::zero()).unwrap(),
diff --git a/util/gen-types/src/extension/tests/check_data.rs b/util/gen-types/src/extension/tests/check_data.rs
index f4c567c370..c66c247392 100644
--- a/util/gen-types/src/extension/tests/check_data.rs
+++ b/util/gen-types/src/extension/tests/check_data.rs
@@ -1,25 +1,17 @@
-use crate::{
-    borrow::ToOwned,
-    packed::{self, Bytes, CellOutput},
-    prelude::*,
-};
+use crate::{borrow::ToOwned, packed, prelude::*};
 
 fn create_transaction(
     outputs: &[&packed::CellOutput],
     outputs_data: &[&[u8]],
     cell_deps: &[&packed::CellDep],
 ) -> packed::Transaction {
-    let outputs_iter: Vec<CellOutput> = outputs.iter().map(|d| d.to_owned().to_owned()).collect();
-    let outputs_data_iter: Vec<Bytes> = outputs_data
-        .iter()
-        .map(|d| Into::<Bytes>::into(d.to_owned()))
-        .collect();
-    let cell_deps_iter: Vec<packed::CellDep> =
-        cell_deps.iter().map(|d| d.to_owned().to_owned()).collect();
+    let outputs_iter = outputs.iter().map(|d| d.to_owned().to_owned());
+    let outputs_data_iter = outputs_data.iter().map(|d| d.to_owned().to_owned().pack());
+    let cell_deps_iter = cell_deps.iter().map(|d| d.to_owned().to_owned());
     let raw = packed::RawTransaction::new_builder()
-        .outputs(outputs_iter)
-        .outputs_data(outputs_data_iter)
-        .cell_deps(cell_deps_iter)
+        .outputs(outputs_iter.pack())
+        .outputs_data(outputs_data_iter.pack())
+        .cell_deps(cell_deps_iter.pack())
         .build();
     packed::Transaction::new_builder().raw(raw).build()
 }
@@ -39,10 +31,10 @@ fn check_data() {
     for ht in 0..4 {
         if ht != 3 {
             for dt in 0..2 {
-                let ht_right = ht;
-                let dt_right = dt;
-                let ht_error = 3;
-                let dt_error = 2;
+                let ht_right = ht.into();
+                let dt_right = dt.into();
+                let ht_error = 3.into();
+                let dt_error = 2.into();
 
                 let script_right = packed::Script::new_builder().hash_type(ht_right).build();
                 let script_error = packed::Script::new_builder().hash_type(ht_error).build();
diff --git a/util/gen-types/src/extension/tests/rust_core_traits.rs b/util/gen-types/src/extension/tests/rust_core_traits.rs
index ee2bd21d9e..b3e3ce1adb 100644
--- a/util/gen-types/src/extension/tests/rust_core_traits.rs
+++ b/util/gen-types/src/extension/tests/rust_core_traits.rs
@@ -4,50 +4,49 @@ use numext_fixed_uint::U256;
 
 #[test]
 fn test_uint32_cmp() {
-    let a: Uint32 = 10u32.into();
-    let b = 20u32.into();
-    let c = 10u32.into();
+    let a: Uint32 = 10u32.pack();
+    let b = 20u32.pack();
+    let c = 10u32.pack();
     assert!(a < b);
     assert!(a == c);
 }
 
 #[test]
 fn test_uint64_cmp() {
-    let a: Uint64 = 10u64.into();
-    let b = 20u64.into();
-    let c = 10u64.into();
+    let a: Uint64 = 10u64.pack();
+    let b = 20u64.pack();
+    let c = 10u64.pack();
     assert!(a < b);
     assert!(a == c);
 
-    let a: Uint64 = 1000u64.into();
-    let b: Uint64 = 2000u64.into();
+    let a: Uint64 = 1000u64.pack();
+    let b: Uint64 = 2000u64.pack();
     assert!(a < b);
 }
 
 #[test]
 fn test_uint128_cmp() {
-    let a: Uint128 = 10u128.into();
-    let b = 20u128.into();
-    let c = 10u128.into();
+    let a: Uint128 = 10u128.pack();
+    let b = 20u128.pack();
+    let c = 10u128.pack();
     assert!(a < b);
     assert!(a == c);
 }
 
 #[test]
 fn test_uint256_cmp() {
-    let a: Uint256 = U256::from(10u32).into();
-    let b = U256::from(20u32).into();
-    let c = U256::from(10u32).into();
+    let a = U256::from(10u32).pack();
+    let b = U256::from(20u32).pack();
+    let c = U256::from(10u32).pack();
     assert!(a < b);
     assert!(a == c);
 }
 
 #[test]
 fn test_byte32_cmp() {
-    let a: Byte32 =
-        h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").into();
-    let b = h256!("0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").into();
-    let c = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").into();
+    let a = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack();
+    let b = h256!("0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack();
+    let c = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack();
 
     assert!(a < b);
     assert!(a == c);
@@ -55,27 +54,24 @@ fn test_byte32_cmp() {
 
 #[test]
 fn test_bytesopt_cmp() {
-    let a: BytesOpt = Some(
-        Into::<Byte32>::into(h256!(
-            "0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
-        ))
-        .as_bytes(),
+    let a = Some(
+        h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562")
+            .pack()
+            .as_bytes(),
     )
-    .into();
+    .pack();
     let b = Some(
-        Into::<Byte32>::into(h256!(
-            "0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
-        ))
-        .as_bytes(),
+        h256!("0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562")
+            .pack()
+            .as_bytes(),
     )
-    .into();
+    .pack();
     let c = Some(
-        Into::<Byte32>::into(h256!(
-            "0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
-        ))
-        .as_bytes(),
+        h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562")
+            .pack()
+            .as_bytes(),
     )
-    .into();
+    .pack();
     let d = BytesOpt::new_builder().build();
 
     assert!(d.is_none());
@@ -86,37 +82,37 @@ fn test_bytesopt_cmp() {
 
 #[test]
 fn test_script_cmp() {
-    let a = Script::new_builder().args([1]).build();
-    let b = Script::new_builder().args([2]).build();
+    let a = Script::new_builder().args([1].pack()).build();
+    let b = Script::new_builder().args([2].pack()).build();
 
     assert!(a < b);
 }
 
 #[test]
 fn test_celldep_cmp() {
-    let a = CellDep::new_builder().dep_type(1).build();
-    let b = CellDep::new_builder().dep_type(2).build();
+    let a = CellDep::new_builder().dep_type(1.into()).build();
+    let b = CellDep::new_builder().dep_type(2.into()).build();
     assert!(a < b);
 }
 
 #[test]
 fn test_outpoint_cmp() {
-    let a = OutPoint::new_builder().index(1u32).build();
-    let b = OutPoint::new_builder().index(2u32).build();
+    let a = OutPoint::new_builder().index(1u32.pack()).build();
+    let b = OutPoint::new_builder().index(2u32.pack()).build();
     assert!(a < b);
 }
 
 #[test]
 fn test_cellinput_cmp() {
-    let a = CellInput::new_builder().since(1000u64).build();
-    let b = CellInput::new_builder().since(2000u64).build();
+    let a = CellInput::new_builder().since(1000u64.pack()).build();
+    let b = CellInput::new_builder().since(2000u64.pack()).build();
     assert!(a > b);
 }
 
 #[test]
 fn test_celloutput_cmp() {
-    let script_lock = Script::new_builder().hash_type(1).build();
-    let script_type = Script::new_builder().hash_type(2).build();
+    let script_lock = Script::new_builder().hash_type(1.into()).build();
+    let script_type = Script::new_builder().hash_type(2.into()).build();
     let script_type_opt = ScriptOpt::new_builder().set(Some(script_type)).build();
     let output_a = CellOutput::new_builder().lock(script_lock.clone()).build();
     let output_b = CellOutput::new_builder()
diff --git a/util/gen-types/src/extension/tests/serialized_size.rs b/util/gen-types/src/extension/tests/serialized_size.rs
index cc1d1bba48..40bba83b2f 100644
--- a/util/gen-types/src/extension/tests/serialized_size.rs
+++ b/util/gen-types/src/extension/tests/serialized_size.rs
@@ -1,17 +1,13 @@
-use crate::{
-    packed::{self, ProposalShortId, ProposalShortIdVec},
-    prelude::*,
-    vec::Vec,
-};
+use crate::{packed, prelude::*, vec, vec::Vec};
 
 #[test]
 fn block_size_should_not_include_uncles_proposals() {
-    let proposal1: ProposalShortId = [1; 10].into();
-    let proposal2: ProposalShortId = [2; 10].into();
-    let proposal3 = [3; 10].into();
-    let proposals1: ProposalShortIdVec = vec![proposal1.clone()].into();
-    let proposals2: ProposalShortIdVec = vec![proposal1.clone(), proposal2.clone()].into();
-    let proposals3: ProposalShortIdVec = vec![proposal1, proposal2, proposal3].into();
+    let proposal1 = [1; 10].pack();
+    let proposal2 = [2; 10].pack();
+    let proposal3 = [3; 10].pack();
+    let proposals1 = vec![proposal1.clone()].pack();
+    let proposals2 = vec![proposal1.clone(), proposal2.clone()].pack();
+    let proposals3 = vec![proposal1, proposal2, proposal3].pack();
     let uncle0 = packed::UncleBlock::new_builder().build();
     let uncle1 = packed::UncleBlock::new_builder()
         .proposals(proposals1)
@@ -35,9 +31,11 @@ fn block_size_should_not_include_uncles_proposals() {
         let mut uncles = uncles.clone();
         loop {
             let block_with_empty_uncles = packed::Block::new_builder()
-                .uncles(empty_uncles.clone())
+                .uncles(empty_uncles.clone().pack())
+                .build();
+            let block_with_uncles = packed::Block::new_builder()
+                .uncles(uncles.clone().pack())
                 .build();
-            let block_with_uncles = packed::Block::new_builder().uncles(uncles.clone()).build();
             let actual = block_with_uncles.serialized_size_without_uncle_proposals();
             let actual_empty = block_with_empty_uncles.serialized_size_without_uncle_proposals();
             let expected = block_with_empty_uncles.as_slice().len();
@@ -56,21 +54,21 @@ fn block_size_should_not_include_uncles_proposals() {
         let mut empty_uncles = empty_uncles;
         let mut uncles = uncles;
         let extensions: Vec<packed::Bytes> = vec![
-            [0u8].into(),
-            [0u8; 24].into(),
-            [0u8; 48].into(),
-            [0u8; 72].into(),
-            [0u8; 96].into(),
+            [0u8].pack(),
+            [0u8; 24].pack(),
+            [0u8; 48].pack(),
+            [0u8; 72].pack(),
+            [0u8; 96].pack(),
         ];
         for extension in extensions {
             loop {
                 let block_with_empty_uncles_v1 = packed::BlockV1::new_builder()
-                    .uncles(empty_uncles.clone())
+                    .uncles(empty_uncles.clone().pack())
                     .extension(extension.clone())
                     .build();
                 let block_with_empty_uncles = block_with_empty_uncles_v1.as_v0();
                 let block_with_uncles = packed::BlockV1::new_builder()
-                    .uncles(uncles.clone())
+                    .uncles(uncles.clone().pack())
                     .extension(extension.clone())
                     .build()
                     .as_v0();
diff --git a/util/gen-types/src/generated/blockchain.rs b/util/gen-types/src/generated/blockchain.rs
index 97c34a09c6..3eb5b9b6b9 100644
--- a/util/gen-types/src/generated/blockchain.rs
+++ b/util/gen-types/src/generated/blockchain.rs
@@ -1,4 +1,4 @@
-// Generated by Molecule 0.8.0
+// Generated by Molecule 0.7.5
 
 use molecule::prelude::*;
 #[derive(Clone)]
@@ -143,7 +143,6 @@ impl<'r> molecule::prelude::Reader<'r> for Uint32Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct Uint32Builder(pub(crate) [Byte; 4]);
 impl ::core::fmt::Debug for Uint32Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -164,39 +163,24 @@ impl Uint32Builder {
     pub const TOTAL_SIZE: usize = 4;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 4;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 4]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 4]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
 }
@@ -220,54 +204,6 @@ impl molecule::prelude::Builder for Uint32Builder {
         Uint32::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 4usize]> for Uint32 {
-    fn from(value: [Byte; 4usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Uint32 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 4usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Uint32> for [Byte; 4usize] {
-    #[track_caller]
-    fn from(value: Uint32) -> Self {
-        [value.nth0(), value.nth1(), value.nth2(), value.nth3()]
-    }
-}
-impl From<[u8; 4usize]> for Uint32 {
-    fn from(value: [u8; 4usize]) -> Self {
-        Uint32Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Uint32 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 4usize]>::try_from(value)?.into())
-    }
-}
-impl From<Uint32> for [u8; 4usize] {
-    #[track_caller]
-    fn from(value: Uint32) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Uint32Reader<'a>> for &'a [u8; 4usize] {
-    #[track_caller]
-    fn from(value: Uint32Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Uint32Reader<'a>> for &'a [u8; 4usize] {
-    #[track_caller]
-    fn from(value: &'a Uint32Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct Uint64(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint64 {
@@ -443,7 +379,6 @@ impl<'r> molecule::prelude::Reader<'r> for Uint64Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct Uint64Builder(pub(crate) [Byte; 8]);
 impl ::core::fmt::Debug for Uint64Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -468,67 +403,40 @@ impl Uint64Builder {
     pub const TOTAL_SIZE: usize = 8;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 8;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 8]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 8]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
-    pub fn nth4<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[4] = v.into();
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
         self
     }
-    pub fn nth5<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[5] = v.into();
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
         self
     }
-    pub fn nth6<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[6] = v.into();
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
         self
     }
-    pub fn nth7<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[7] = v.into();
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
         self
     }
 }
@@ -556,63 +464,6 @@ impl molecule::prelude::Builder for Uint64Builder {
         Uint64::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 8usize]> for Uint64 {
-    fn from(value: [Byte; 8usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Uint64 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 8usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Uint64> for [Byte; 8usize] {
-    #[track_caller]
-    fn from(value: Uint64) -> Self {
-        [
-            value.nth0(),
-            value.nth1(),
-            value.nth2(),
-            value.nth3(),
-            value.nth4(),
-            value.nth5(),
-            value.nth6(),
-            value.nth7(),
-        ]
-    }
-}
-impl From<[u8; 8usize]> for Uint64 {
-    fn from(value: [u8; 8usize]) -> Self {
-        Uint64Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Uint64 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 8usize]>::try_from(value)?.into())
-    }
-}
-impl From<Uint64> for [u8; 8usize] {
-    #[track_caller]
-    fn from(value: Uint64) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Uint64Reader<'a>> for &'a [u8; 8usize] {
-    #[track_caller]
-    fn from(value: Uint64Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Uint64Reader<'a>> for &'a [u8; 8usize] {
-    #[track_caller]
-    fn from(value: &'a Uint64Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct Uint128(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint128 {
@@ -844,7 +695,6 @@ impl<'r> molecule::prelude::Reader<'r> for Uint128Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct Uint128Builder(pub(crate) [Byte; 16]);
 impl ::core::fmt::Debug for Uint128Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -877,123 +727,72 @@ impl Uint128Builder {
     pub const TOTAL_SIZE: usize = 16;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 16;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 16]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 16]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
-    pub fn nth4<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[4] = v.into();
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
         self
     }
-    pub fn nth5<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[5] = v.into();
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
         self
     }
-    pub fn nth6<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[6] = v.into();
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
         self
     }
-    pub fn nth7<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[7] = v.into();
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
         self
     }
-    pub fn nth8<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[8] = v.into();
+    pub fn nth8(mut self, v: Byte) -> Self {
+        self.0[8] = v;
         self
     }
-    pub fn nth9<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[9] = v.into();
+    pub fn nth9(mut self, v: Byte) -> Self {
+        self.0[9] = v;
         self
     }
-    pub fn nth10<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[10] = v.into();
+    pub fn nth10(mut self, v: Byte) -> Self {
+        self.0[10] = v;
         self
     }
-    pub fn nth11<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[11] = v.into();
+    pub fn nth11(mut self, v: Byte) -> Self {
+        self.0[11] = v;
         self
     }
-    pub fn nth12<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[12] = v.into();
+    pub fn nth12(mut self, v: Byte) -> Self {
+        self.0[12] = v;
         self
     }
-    pub fn nth13<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[13] = v.into();
+    pub fn nth13(mut self, v: Byte) -> Self {
+        self.0[13] = v;
         self
     }
-    pub fn nth14<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[14] = v.into();
+    pub fn nth14(mut self, v: Byte) -> Self {
+        self.0[14] = v;
         self
     }
-    pub fn nth15<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[15] = v.into();
+    pub fn nth15(mut self, v: Byte) -> Self {
+        self.0[15] = v;
         self
     }
 }
@@ -1029,71 +828,6 @@ impl molecule::prelude::Builder for Uint128Builder {
         Uint128::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 16usize]> for Uint128 {
-    fn from(value: [Byte; 16usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Uint128 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 16usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Uint128> for [Byte; 16usize] {
-    #[track_caller]
-    fn from(value: Uint128) -> Self {
-        [
-            value.nth0(),
-            value.nth1(),
-            value.nth2(),
-            value.nth3(),
-            value.nth4(),
-            value.nth5(),
-            value.nth6(),
-            value.nth7(),
-            value.nth8(),
-            value.nth9(),
-            value.nth10(),
-            value.nth11(),
-            value.nth12(),
-            value.nth13(),
-            value.nth14(),
-            value.nth15(),
-        ]
-    }
-}
-impl From<[u8; 16usize]> for Uint128 {
-    fn from(value: [u8; 16usize]) -> Self {
-        Uint128Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Uint128 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 16usize]>::try_from(value)?.into())
-    }
-}
-impl From<Uint128> for [u8; 16usize] {
-    #[track_caller]
-    fn from(value: Uint128) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Uint128Reader<'a>> for &'a [u8; 16usize] {
-    #[track_caller]
-    fn from(value: Uint128Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Uint128Reader<'a>> for &'a [u8; 16usize] {
-    #[track_caller]
-    fn from(value: &'a Uint128Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct Byte32(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Byte32 {
@@ -1440,7 +1174,6 @@ impl<'r> molecule::prelude::Reader<'r> for Byte32Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct Byte32Builder(pub(crate) [Byte; 32]);
 impl ::core::fmt::Debug for Byte32Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -1489,235 +1222,136 @@ impl Byte32Builder {
     pub const TOTAL_SIZE: usize = 32;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 32;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 32]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 32]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
-    pub fn nth4<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[4] = v.into();
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
         self
     }
-    pub fn nth5<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[5] = v.into();
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
         self
     }
-    pub fn nth6<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[6] = v.into();
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
         self
     }
-    pub fn nth7<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[7] = v.into();
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
         self
     }
-    pub fn nth8<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[8] = v.into();
+    pub fn nth8(mut self, v: Byte) -> Self {
+        self.0[8] = v;
         self
     }
-    pub fn nth9<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[9] = v.into();
+    pub fn nth9(mut self, v: Byte) -> Self {
+        self.0[9] = v;
         self
     }
-    pub fn nth10<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[10] = v.into();
+    pub fn nth10(mut self, v: Byte) -> Self {
+        self.0[10] = v;
         self
     }
-    pub fn nth11<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[11] = v.into();
+    pub fn nth11(mut self, v: Byte) -> Self {
+        self.0[11] = v;
         self
     }
-    pub fn nth12<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[12] = v.into();
+    pub fn nth12(mut self, v: Byte) -> Self {
+        self.0[12] = v;
         self
     }
-    pub fn nth13<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[13] = v.into();
+    pub fn nth13(mut self, v: Byte) -> Self {
+        self.0[13] = v;
         self
     }
-    pub fn nth14<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[14] = v.into();
+    pub fn nth14(mut self, v: Byte) -> Self {
+        self.0[14] = v;
         self
     }
-    pub fn nth15<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[15] = v.into();
+    pub fn nth15(mut self, v: Byte) -> Self {
+        self.0[15] = v;
         self
     }
-    pub fn nth16<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[16] = v.into();
+    pub fn nth16(mut self, v: Byte) -> Self {
+        self.0[16] = v;
         self
     }
-    pub fn nth17<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[17] = v.into();
+    pub fn nth17(mut self, v: Byte) -> Self {
+        self.0[17] = v;
         self
     }
-    pub fn nth18<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[18] = v.into();
+    pub fn nth18(mut self, v: Byte) -> Self {
+        self.0[18] = v;
         self
     }
-    pub fn nth19<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[19] = v.into();
+    pub fn nth19(mut self, v: Byte) -> Self {
+        self.0[19] = v;
         self
     }
-    pub fn nth20<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[20] = v.into();
+    pub fn nth20(mut self, v: Byte) -> Self {
+        self.0[20] = v;
         self
     }
-    pub fn nth21<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[21] = v.into();
+    pub fn nth21(mut self, v: Byte) -> Self {
+        self.0[21] = v;
         self
     }
-    pub fn nth22<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[22] = v.into();
+    pub fn nth22(mut self, v: Byte) -> Self {
+        self.0[22] = v;
         self
     }
-    pub fn nth23<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[23] = v.into();
+    pub fn nth23(mut self, v: Byte) -> Self {
+        self.0[23] = v;
         self
     }
-    pub fn nth24<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[24] = v.into();
+    pub fn nth24(mut self, v: Byte) -> Self {
+        self.0[24] = v;
         self
     }
-    pub fn nth25<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[25] = v.into();
+    pub fn nth25(mut self, v: Byte) -> Self {
+        self.0[25] = v;
         self
     }
-    pub fn nth26<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[26] = v.into();
+    pub fn nth26(mut self, v: Byte) -> Self {
+        self.0[26] = v;
         self
     }
-    pub fn nth27<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[27] = v.into();
+    pub fn nth27(mut self, v: Byte) -> Self {
+        self.0[27] = v;
         self
     }
-    pub fn nth28<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[28] = v.into();
+    pub fn nth28(mut self, v: Byte) -> Self {
+        self.0[28] = v;
         self
     }
-    pub fn nth29<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[29] = v.into();
+    pub fn nth29(mut self, v: Byte) -> Self {
+        self.0[29] = v;
         self
     }
-    pub fn nth30<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[30] = v.into();
+    pub fn nth30(mut self, v: Byte) -> Self {
+        self.0[30] = v;
         self
     }
-    pub fn nth31<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[31] = v.into();
+    pub fn nth31(mut self, v: Byte) -> Self {
+        self.0[31] = v;
         self
     }
 }
@@ -1769,87 +1403,6 @@ impl molecule::prelude::Builder for Byte32Builder {
         Byte32::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 32usize]> for Byte32 {
-    fn from(value: [Byte; 32usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Byte32 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 32usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Byte32> for [Byte; 32usize] {
-    #[track_caller]
-    fn from(value: Byte32) -> Self {
-        [
-            value.nth0(),
-            value.nth1(),
-            value.nth2(),
-            value.nth3(),
-            value.nth4(),
-            value.nth5(),
-            value.nth6(),
-            value.nth7(),
-            value.nth8(),
-            value.nth9(),
-            value.nth10(),
-            value.nth11(),
-            value.nth12(),
-            value.nth13(),
-            value.nth14(),
-            value.nth15(),
-            value.nth16(),
-            value.nth17(),
-            value.nth18(),
-            value.nth19(),
-            value.nth20(),
-            value.nth21(),
-            value.nth22(),
-            value.nth23(),
-            value.nth24(),
-            value.nth25(),
-            value.nth26(),
-            value.nth27(),
-            value.nth28(),
-            value.nth29(),
-            value.nth30(),
-            value.nth31(),
-        ]
-    }
-}
-impl From<[u8; 32usize]> for Byte32 {
-    fn from(value: [u8; 32usize]) -> Self {
-        Byte32Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Byte32 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 32usize]>::try_from(value)?.into())
-    }
-}
-impl From<Byte32> for [u8; 32usize] {
-    #[track_caller]
-    fn from(value: Byte32) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Byte32Reader<'a>> for &'a [u8; 32usize] {
-    #[track_caller]
-    fn from(value: Byte32Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Byte32Reader<'a>> for &'a [u8; 32usize] {
-    #[track_caller]
-    fn from(value: &'a Byte32Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct Uint256(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint256 {
@@ -2196,7 +1749,6 @@ impl<'r> molecule::prelude::Reader<'r> for Uint256Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct Uint256Builder(pub(crate) [Byte; 32]);
 impl ::core::fmt::Debug for Uint256Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -2245,235 +1797,136 @@ impl Uint256Builder {
     pub const TOTAL_SIZE: usize = 32;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 32;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 32]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 32]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
-    pub fn nth4<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[4] = v.into();
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
         self
     }
-    pub fn nth5<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[5] = v.into();
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
         self
     }
-    pub fn nth6<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[6] = v.into();
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
         self
     }
-    pub fn nth7<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[7] = v.into();
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
         self
     }
-    pub fn nth8<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[8] = v.into();
+    pub fn nth8(mut self, v: Byte) -> Self {
+        self.0[8] = v;
         self
     }
-    pub fn nth9<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[9] = v.into();
+    pub fn nth9(mut self, v: Byte) -> Self {
+        self.0[9] = v;
         self
     }
-    pub fn nth10<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[10] = v.into();
+    pub fn nth10(mut self, v: Byte) -> Self {
+        self.0[10] = v;
         self
     }
-    pub fn nth11<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[11] = v.into();
+    pub fn nth11(mut self, v: Byte) -> Self {
+        self.0[11] = v;
         self
     }
-    pub fn nth12<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[12] = v.into();
+    pub fn nth12(mut self, v: Byte) -> Self {
+        self.0[12] = v;
         self
     }
-    pub fn nth13<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[13] = v.into();
+    pub fn nth13(mut self, v: Byte) -> Self {
+        self.0[13] = v;
         self
     }
-    pub fn nth14<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[14] = v.into();
+    pub fn nth14(mut self, v: Byte) -> Self {
+        self.0[14] = v;
         self
     }
-    pub fn nth15<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[15] = v.into();
+    pub fn nth15(mut self, v: Byte) -> Self {
+        self.0[15] = v;
         self
     }
-    pub fn nth16<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[16] = v.into();
+    pub fn nth16(mut self, v: Byte) -> Self {
+        self.0[16] = v;
         self
     }
-    pub fn nth17<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[17] = v.into();
+    pub fn nth17(mut self, v: Byte) -> Self {
+        self.0[17] = v;
         self
     }
-    pub fn nth18<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[18] = v.into();
+    pub fn nth18(mut self, v: Byte) -> Self {
+        self.0[18] = v;
         self
     }
-    pub fn nth19<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[19] = v.into();
+    pub fn nth19(mut self, v: Byte) -> Self {
+        self.0[19] = v;
         self
     }
-    pub fn nth20<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[20] = v.into();
+    pub fn nth20(mut self, v: Byte) -> Self {
+        self.0[20] = v;
         self
     }
-    pub fn nth21<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[21] = v.into();
+    pub fn nth21(mut self, v: Byte) -> Self {
+        self.0[21] = v;
         self
     }
-    pub fn nth22<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[22] = v.into();
+    pub fn nth22(mut self, v: Byte) -> Self {
+        self.0[22] = v;
         self
     }
-    pub fn nth23<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[23] = v.into();
+    pub fn nth23(mut self, v: Byte) -> Self {
+        self.0[23] = v;
         self
     }
-    pub fn nth24<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[24] = v.into();
+    pub fn nth24(mut self, v: Byte) -> Self {
+        self.0[24] = v;
         self
     }
-    pub fn nth25<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[25] = v.into();
+    pub fn nth25(mut self, v: Byte) -> Self {
+        self.0[25] = v;
         self
     }
-    pub fn nth26<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[26] = v.into();
+    pub fn nth26(mut self, v: Byte) -> Self {
+        self.0[26] = v;
         self
     }
-    pub fn nth27<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[27] = v.into();
+    pub fn nth27(mut self, v: Byte) -> Self {
+        self.0[27] = v;
         self
     }
-    pub fn nth28<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[28] = v.into();
+    pub fn nth28(mut self, v: Byte) -> Self {
+        self.0[28] = v;
         self
     }
-    pub fn nth29<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[29] = v.into();
+    pub fn nth29(mut self, v: Byte) -> Self {
+        self.0[29] = v;
         self
     }
-    pub fn nth30<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[30] = v.into();
+    pub fn nth30(mut self, v: Byte) -> Self {
+        self.0[30] = v;
         self
     }
-    pub fn nth31<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[31] = v.into();
+    pub fn nth31(mut self, v: Byte) -> Self {
+        self.0[31] = v;
         self
     }
 }
@@ -2525,87 +1978,6 @@ impl molecule::prelude::Builder for Uint256Builder {
         Uint256::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 32usize]> for Uint256 {
-    fn from(value: [Byte; 32usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Uint256 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 32usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Uint256> for [Byte; 32usize] {
-    #[track_caller]
-    fn from(value: Uint256) -> Self {
-        [
-            value.nth0(),
-            value.nth1(),
-            value.nth2(),
-            value.nth3(),
-            value.nth4(),
-            value.nth5(),
-            value.nth6(),
-            value.nth7(),
-            value.nth8(),
-            value.nth9(),
-            value.nth10(),
-            value.nth11(),
-            value.nth12(),
-            value.nth13(),
-            value.nth14(),
-            value.nth15(),
-            value.nth16(),
-            value.nth17(),
-            value.nth18(),
-            value.nth19(),
-            value.nth20(),
-            value.nth21(),
-            value.nth22(),
-            value.nth23(),
-            value.nth24(),
-            value.nth25(),
-            value.nth26(),
-            value.nth27(),
-            value.nth28(),
-            value.nth29(),
-            value.nth30(),
-            value.nth31(),
-        ]
-    }
-}
-impl From<[u8; 32usize]> for Uint256 {
-    fn from(value: [u8; 32usize]) -> Self {
-        Uint256Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Uint256 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 32usize]>::try_from(value)?.into())
-    }
-}
-impl From<Uint256> for [u8; 32usize] {
-    #[track_caller]
-    fn from(value: Uint256) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Uint256Reader<'a>> for &'a [u8; 32usize] {
-    #[track_caller]
-    fn from(value: Uint256Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Uint256Reader<'a>> for &'a [u8; 32usize] {
-    #[track_caller]
-    fn from(value: &'a Uint256Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct Bytes(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Bytes {
@@ -2779,7 +2151,7 @@ impl<'r> molecule::prelude::Reader<'r> for BytesReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BytesBuilder(pub(crate) Vec<Byte>);
 impl BytesBuilder {
     pub const ITEM_SIZE: usize = 1;
@@ -2787,24 +2159,20 @@ impl BytesBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Byte) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Byte>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Byte>
-    where
-        T: ::core::convert::Into<Byte>,
-    {
+    pub fn replace(&mut self, index: usize, v: Byte) -> Option<Byte> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for BytesBuilder {
@@ -2853,30 +2221,6 @@ impl ::core::iter::IntoIterator for Bytes {
         BytesIterator(self, 0, len)
     }
 }
-impl ::core::iter::FromIterator<Byte> for Bytes {
-    fn from_iter<T: IntoIterator<Item = Byte>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Byte>> for Bytes {
-    fn from(v: Vec<Byte>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
-impl ::core::iter::FromIterator<u8> for Bytes {
-    fn from_iter<T: IntoIterator<Item = u8>>(iter: T) -> Self {
-        Self::new_builder()
-            .extend(iter.into_iter().map(Into::into))
-            .build()
-    }
-}
-impl From<Vec<u8>> for Bytes {
-    fn from(v: Vec<u8>) -> Self {
-        Self::new_builder()
-            .set(v.into_iter().map(Into::into).collect())
-            .build()
-    }
-}
 #[derive(Clone)]
 pub struct BytesOpt(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BytesOpt {
@@ -3011,14 +2355,11 @@ impl<'r> molecule::prelude::Reader<'r> for BytesOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BytesOptBuilder(pub(crate) Option<Bytes>);
 impl BytesOptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<Bytes>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<Bytes>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -3044,11 +2385,6 @@ impl molecule::prelude::Builder for BytesOptBuilder {
         BytesOpt::new_unchecked(inner.into())
     }
 }
-impl From<Bytes> for BytesOpt {
-    fn from(value: Bytes) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct BytesOptVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BytesOptVec {
@@ -3272,31 +2608,27 @@ impl<'r> molecule::prelude::Reader<'r> for BytesOptVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BytesOptVecBuilder(pub(crate) Vec<BytesOpt>);
 impl BytesOptVecBuilder {
     pub fn set(mut self, v: Vec<BytesOpt>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: BytesOpt) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = BytesOpt>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<BytesOpt>
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
+    pub fn replace(&mut self, index: usize, v: BytesOpt) -> Option<BytesOpt> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for BytesOptVecBuilder {
@@ -3393,16 +2725,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for BytesOptVecReaderIterator<'
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<BytesOpt> for BytesOptVec {
-    fn from_iter<T: IntoIterator<Item = BytesOpt>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<BytesOpt>> for BytesOptVec {
-    fn from(v: Vec<BytesOpt>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct BytesVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BytesVec {
@@ -3626,31 +2948,27 @@ impl<'r> molecule::prelude::Reader<'r> for BytesVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BytesVecBuilder(pub(crate) Vec<Bytes>);
 impl BytesVecBuilder {
     pub fn set(mut self, v: Vec<Bytes>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Bytes) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Bytes>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Bytes>
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
+    pub fn replace(&mut self, index: usize, v: Bytes) -> Option<Bytes> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for BytesVecBuilder {
@@ -3747,16 +3065,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for BytesVecReaderIterator<'t,
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Bytes> for BytesVec {
-    fn from_iter<T: IntoIterator<Item = Bytes>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Bytes>> for BytesVec {
-    fn from(v: Vec<Bytes>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Byte32Vec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Byte32Vec {
@@ -3936,7 +3244,7 @@ impl<'r> molecule::prelude::Reader<'r> for Byte32VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Byte32VecBuilder(pub(crate) Vec<Byte32>);
 impl Byte32VecBuilder {
     pub const ITEM_SIZE: usize = 32;
@@ -3944,24 +3252,20 @@ impl Byte32VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Byte32) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Byte32>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Byte32>
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
+    pub fn replace(&mut self, index: usize, v: Byte32) -> Option<Byte32> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for Byte32VecBuilder {
@@ -4033,16 +3337,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for Byte32VecReaderIterator<'t,
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Byte32> for Byte32Vec {
-    fn from_iter<T: IntoIterator<Item = Byte32>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Byte32>> for Byte32Vec {
-    fn from(v: Vec<Byte32>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct ScriptOpt(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for ScriptOpt {
@@ -4177,14 +3471,11 @@ impl<'r> molecule::prelude::Reader<'r> for ScriptOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct ScriptOptBuilder(pub(crate) Option<Script>);
 impl ScriptOptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<Script>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<Script>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -4210,11 +3501,6 @@ impl molecule::prelude::Builder for ScriptOptBuilder {
         ScriptOpt::new_unchecked(inner.into())
     }
 }
-impl From<Script> for ScriptOpt {
-    fn from(value: Script) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct ProposalShortId(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for ProposalShortId {
@@ -4404,7 +3690,6 @@ impl<'r> molecule::prelude::Reader<'r> for ProposalShortIdReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct ProposalShortIdBuilder(pub(crate) [Byte; 10]);
 impl ::core::fmt::Debug for ProposalShortIdBuilder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -4431,81 +3716,48 @@ impl ProposalShortIdBuilder {
     pub const TOTAL_SIZE: usize = 10;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 10;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 10]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 10]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
-    pub fn nth4<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[4] = v.into();
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
         self
     }
-    pub fn nth5<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[5] = v.into();
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
         self
     }
-    pub fn nth6<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[6] = v.into();
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
         self
     }
-    pub fn nth7<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[7] = v.into();
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
         self
     }
-    pub fn nth8<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[8] = v.into();
+    pub fn nth8(mut self, v: Byte) -> Self {
+        self.0[8] = v;
         self
     }
-    pub fn nth9<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[9] = v.into();
+    pub fn nth9(mut self, v: Byte) -> Self {
+        self.0[9] = v;
         self
     }
 }
@@ -4535,65 +3787,6 @@ impl molecule::prelude::Builder for ProposalShortIdBuilder {
         ProposalShortId::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 10usize]> for ProposalShortId {
-    fn from(value: [Byte; 10usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for ProposalShortId {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 10usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<ProposalShortId> for [Byte; 10usize] {
-    #[track_caller]
-    fn from(value: ProposalShortId) -> Self {
-        [
-            value.nth0(),
-            value.nth1(),
-            value.nth2(),
-            value.nth3(),
-            value.nth4(),
-            value.nth5(),
-            value.nth6(),
-            value.nth7(),
-            value.nth8(),
-            value.nth9(),
-        ]
-    }
-}
-impl From<[u8; 10usize]> for ProposalShortId {
-    fn from(value: [u8; 10usize]) -> Self {
-        ProposalShortIdReader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for ProposalShortId {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 10usize]>::try_from(value)?.into())
-    }
-}
-impl From<ProposalShortId> for [u8; 10usize] {
-    #[track_caller]
-    fn from(value: ProposalShortId) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<ProposalShortIdReader<'a>> for &'a [u8; 10usize] {
-    #[track_caller]
-    fn from(value: ProposalShortIdReader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a ProposalShortIdReader<'a>> for &'a [u8; 10usize] {
-    #[track_caller]
-    fn from(value: &'a ProposalShortIdReader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct UncleBlockVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for UncleBlockVec {
@@ -4817,31 +4010,27 @@ impl<'r> molecule::prelude::Reader<'r> for UncleBlockVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct UncleBlockVecBuilder(pub(crate) Vec<UncleBlock>);
 impl UncleBlockVecBuilder {
     pub fn set(mut self, v: Vec<UncleBlock>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<UncleBlock>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: UncleBlock) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = UncleBlock>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<UncleBlock>
-    where
-        T: ::core::convert::Into<UncleBlock>,
-    {
+    pub fn replace(&mut self, index: usize, v: UncleBlock) -> Option<UncleBlock> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for UncleBlockVecBuilder {
@@ -4938,16 +4127,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for UncleBlockVecReaderIterator
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<UncleBlock> for UncleBlockVec {
-    fn from_iter<T: IntoIterator<Item = UncleBlock>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<UncleBlock>> for UncleBlockVec {
-    fn from(v: Vec<UncleBlock>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct TransactionVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for TransactionVec {
@@ -5171,31 +4350,27 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct TransactionVecBuilder(pub(crate) Vec<Transaction>);
 impl TransactionVecBuilder {
     pub fn set(mut self, v: Vec<Transaction>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Transaction>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Transaction) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Transaction>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Transaction>
-    where
-        T: ::core::convert::Into<Transaction>,
-    {
+    pub fn replace(&mut self, index: usize, v: Transaction) -> Option<Transaction> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for TransactionVecBuilder {
@@ -5292,16 +4467,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for TransactionVecReaderIterato
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Transaction> for TransactionVec {
-    fn from_iter<T: IntoIterator<Item = Transaction>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Transaction>> for TransactionVec {
-    fn from(v: Vec<Transaction>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct ProposalShortIdVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for ProposalShortIdVec {
@@ -5481,7 +4646,7 @@ impl<'r> molecule::prelude::Reader<'r> for ProposalShortIdVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct ProposalShortIdVecBuilder(pub(crate) Vec<ProposalShortId>);
 impl ProposalShortIdVecBuilder {
     pub const ITEM_SIZE: usize = 10;
@@ -5489,27 +4654,23 @@ impl ProposalShortIdVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortId>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: ProposalShortId) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = ProposalShortId>>(
         mut self,
         iter: T,
     ) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<ProposalShortId>
-    where
-        T: ::core::convert::Into<ProposalShortId>,
-    {
+    pub fn replace(&mut self, index: usize, v: ProposalShortId) -> Option<ProposalShortId> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for ProposalShortIdVecBuilder {
@@ -5581,16 +4742,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for ProposalShortIdVecReaderIte
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<ProposalShortId> for ProposalShortIdVec {
-    fn from_iter<T: IntoIterator<Item = ProposalShortId>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<ProposalShortId>> for ProposalShortIdVec {
-    fn from(v: Vec<ProposalShortId>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct CellDepVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for CellDepVec {
@@ -5770,7 +4921,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellDepVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellDepVecBuilder(pub(crate) Vec<CellDep>);
 impl CellDepVecBuilder {
     pub const ITEM_SIZE: usize = 37;
@@ -5778,24 +4929,20 @@ impl CellDepVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellDep>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: CellDep) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellDep>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<CellDep>
-    where
-        T: ::core::convert::Into<CellDep>,
-    {
+    pub fn replace(&mut self, index: usize, v: CellDep) -> Option<CellDep> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for CellDepVecBuilder {
@@ -5867,16 +5014,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for CellDepVecReaderIterator<'t
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<CellDep> for CellDepVec {
-    fn from_iter<T: IntoIterator<Item = CellDep>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<CellDep>> for CellDepVec {
-    fn from(v: Vec<CellDep>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct CellInputVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for CellInputVec {
@@ -6056,7 +5193,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellInputVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellInputVecBuilder(pub(crate) Vec<CellInput>);
 impl CellInputVecBuilder {
     pub const ITEM_SIZE: usize = 44;
@@ -6064,24 +5201,20 @@ impl CellInputVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellInput>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: CellInput) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellInput>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<CellInput>
-    where
-        T: ::core::convert::Into<CellInput>,
-    {
+    pub fn replace(&mut self, index: usize, v: CellInput) -> Option<CellInput> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for CellInputVecBuilder {
@@ -6153,16 +5286,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for CellInputVecReaderIterator<
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<CellInput> for CellInputVec {
-    fn from_iter<T: IntoIterator<Item = CellInput>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<CellInput>> for CellInputVec {
-    fn from(v: Vec<CellInput>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct CellOutputVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for CellOutputVec {
@@ -6386,31 +5509,27 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellOutputVecBuilder(pub(crate) Vec<CellOutput>);
 impl CellOutputVecBuilder {
     pub fn set(mut self, v: Vec<CellOutput>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellOutput>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: CellOutput) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellOutput>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<CellOutput>
-    where
-        T: ::core::convert::Into<CellOutput>,
-    {
+    pub fn replace(&mut self, index: usize, v: CellOutput) -> Option<CellOutput> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for CellOutputVecBuilder {
@@ -6507,16 +5626,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for CellOutputVecReaderIterator
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<CellOutput> for CellOutputVec {
-    fn from_iter<T: IntoIterator<Item = CellOutput>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<CellOutput>> for CellOutputVec {
-    fn from(v: Vec<CellOutput>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Script(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Script {
@@ -6750,7 +5859,7 @@ impl<'r> molecule::prelude::Reader<'r> for ScriptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct ScriptBuilder {
     pub(crate) code_hash: Byte32,
     pub(crate) hash_type: Byte,
@@ -6758,25 +5867,16 @@ pub struct ScriptBuilder {
 }
 impl ScriptBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn code_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.code_hash = v.into();
+    pub fn code_hash(mut self, v: Byte32) -> Self {
+        self.code_hash = v;
         self
     }
-    pub fn hash_type<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.hash_type = v.into();
+    pub fn hash_type(mut self, v: Byte) -> Self {
+        self.hash_type = v;
         self
     }
-    pub fn args<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.args = v.into();
+    pub fn args(mut self, v: Bytes) -> Self {
+        self.args = v;
         self
     }
 }
@@ -6945,7 +6045,7 @@ impl<'r> molecule::prelude::Reader<'r> for OutPointReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct OutPointBuilder {
     pub(crate) tx_hash: Byte32,
     pub(crate) index: Uint32,
@@ -6954,18 +6054,12 @@ impl OutPointBuilder {
     pub const TOTAL_SIZE: usize = 36;
     pub const FIELD_SIZES: [usize; 2] = [32, 4];
     pub const FIELD_COUNT: usize = 2;
-    pub fn tx_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.tx_hash = v.into();
+    pub fn tx_hash(mut self, v: Byte32) -> Self {
+        self.tx_hash = v;
         self
     }
-    pub fn index<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.index = v.into();
+    pub fn index(mut self, v: Uint32) -> Self {
+        self.index = v;
         self
     }
 }
@@ -7118,7 +6212,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellInputReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellInputBuilder {
     pub(crate) since: Uint64,
     pub(crate) previous_output: OutPoint,
@@ -7127,18 +6221,12 @@ impl CellInputBuilder {
     pub const TOTAL_SIZE: usize = 44;
     pub const FIELD_SIZES: [usize; 2] = [8, 36];
     pub const FIELD_COUNT: usize = 2;
-    pub fn since<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.since = v.into();
+    pub fn since(mut self, v: Uint64) -> Self {
+        self.since = v;
         self
     }
-    pub fn previous_output<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<OutPoint>,
-    {
-        self.previous_output = v.into();
+    pub fn previous_output(mut self, v: OutPoint) -> Self {
+        self.previous_output = v;
         self
     }
 }
@@ -7394,7 +6482,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellOutputBuilder {
     pub(crate) capacity: Uint64,
     pub(crate) lock: Script,
@@ -7402,25 +6490,16 @@ pub struct CellOutputBuilder {
 }
 impl CellOutputBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn capacity<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.capacity = v.into();
+    pub fn capacity(mut self, v: Uint64) -> Self {
+        self.capacity = v;
         self
     }
-    pub fn lock<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Script>,
-    {
-        self.lock = v.into();
+    pub fn lock(mut self, v: Script) -> Self {
+        self.lock = v;
         self
     }
-    pub fn type_<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ScriptOpt>,
-    {
-        self.type_ = v.into();
+    pub fn type_(mut self, v: ScriptOpt) -> Self {
+        self.type_ = v;
         self
     }
 }
@@ -7589,7 +6668,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellDepReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellDepBuilder {
     pub(crate) out_point: OutPoint,
     pub(crate) dep_type: Byte,
@@ -7598,18 +6677,12 @@ impl CellDepBuilder {
     pub const TOTAL_SIZE: usize = 37;
     pub const FIELD_SIZES: [usize; 2] = [36, 1];
     pub const FIELD_COUNT: usize = 2;
-    pub fn out_point<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<OutPoint>,
-    {
-        self.out_point = v.into();
+    pub fn out_point(mut self, v: OutPoint) -> Self {
+        self.out_point = v;
         self
     }
-    pub fn dep_type<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.dep_type = v.into();
+    pub fn dep_type(mut self, v: Byte) -> Self {
+        self.dep_type = v;
         self
     }
 }
@@ -7912,7 +6985,7 @@ impl<'r> molecule::prelude::Reader<'r> for RawTransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RawTransactionBuilder {
     pub(crate) version: Uint32,
     pub(crate) cell_deps: CellDepVec,
@@ -7923,46 +6996,28 @@ pub struct RawTransactionBuilder {
 }
 impl RawTransactionBuilder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.version = v.into();
+    pub fn version(mut self, v: Uint32) -> Self {
+        self.version = v;
         self
     }
-    pub fn cell_deps<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellDepVec>,
-    {
-        self.cell_deps = v.into();
+    pub fn cell_deps(mut self, v: CellDepVec) -> Self {
+        self.cell_deps = v;
         self
     }
-    pub fn header_deps<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.header_deps = v.into();
+    pub fn header_deps(mut self, v: Byte32Vec) -> Self {
+        self.header_deps = v;
         self
     }
-    pub fn inputs<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellInputVec>,
-    {
-        self.inputs = v.into();
+    pub fn inputs(mut self, v: CellInputVec) -> Self {
+        self.inputs = v;
         self
     }
-    pub fn outputs<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellOutputVec>,
-    {
-        self.outputs = v.into();
+    pub fn outputs(mut self, v: CellOutputVec) -> Self {
+        self.outputs = v;
         self
     }
-    pub fn outputs_data<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesVec>,
-    {
-        self.outputs_data = v.into();
+    pub fn outputs_data(mut self, v: BytesVec) -> Self {
+        self.outputs_data = v;
         self
     }
 }
@@ -8230,25 +7285,19 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct TransactionBuilder {
     pub(crate) raw: RawTransaction,
     pub(crate) witnesses: BytesVec,
 }
 impl TransactionBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn raw<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<RawTransaction>,
-    {
-        self.raw = v.into();
+    pub fn raw(mut self, v: RawTransaction) -> Self {
+        self.raw = v;
         self
     }
-    pub fn witnesses<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesVec>,
-    {
-        self.witnesses = v.into();
+    pub fn witnesses(mut self, v: BytesVec) -> Self {
+        self.witnesses = v;
         self
     }
 }
@@ -8490,7 +7539,7 @@ impl<'r> molecule::prelude::Reader<'r> for RawHeaderReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RawHeaderBuilder {
     pub(crate) version: Uint32,
     pub(crate) compact_target: Uint32,
@@ -8507,74 +7556,44 @@ impl RawHeaderBuilder {
     pub const TOTAL_SIZE: usize = 192;
     pub const FIELD_SIZES: [usize; 10] = [4, 4, 8, 8, 8, 32, 32, 32, 32, 32];
     pub const FIELD_COUNT: usize = 10;
-    pub fn version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.version = v.into();
+    pub fn version(mut self, v: Uint32) -> Self {
+        self.version = v;
         self
     }
-    pub fn compact_target<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.compact_target = v.into();
+    pub fn compact_target(mut self, v: Uint32) -> Self {
+        self.compact_target = v;
         self
     }
-    pub fn timestamp<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.timestamp = v.into();
+    pub fn timestamp(mut self, v: Uint64) -> Self {
+        self.timestamp = v;
         self
     }
-    pub fn number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.number = v.into();
+    pub fn number(mut self, v: Uint64) -> Self {
+        self.number = v;
         self
     }
-    pub fn epoch<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.epoch = v.into();
+    pub fn epoch(mut self, v: Uint64) -> Self {
+        self.epoch = v;
         self
     }
-    pub fn parent_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.parent_hash = v.into();
+    pub fn parent_hash(mut self, v: Byte32) -> Self {
+        self.parent_hash = v;
         self
     }
-    pub fn transactions_root<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.transactions_root = v.into();
+    pub fn transactions_root(mut self, v: Byte32) -> Self {
+        self.transactions_root = v;
         self
     }
-    pub fn proposals_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.proposals_hash = v.into();
+    pub fn proposals_hash(mut self, v: Byte32) -> Self {
+        self.proposals_hash = v;
         self
     }
-    pub fn extra_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.extra_hash = v.into();
+    pub fn extra_hash(mut self, v: Byte32) -> Self {
+        self.extra_hash = v;
         self
     }
-    pub fn dao<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.dao = v.into();
+    pub fn dao(mut self, v: Byte32) -> Self {
+        self.dao = v;
         self
     }
 }
@@ -8738,7 +7757,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct HeaderBuilder {
     pub(crate) raw: RawHeader,
     pub(crate) nonce: Uint128,
@@ -8747,18 +7766,12 @@ impl HeaderBuilder {
     pub const TOTAL_SIZE: usize = 208;
     pub const FIELD_SIZES: [usize; 2] = [192, 16];
     pub const FIELD_COUNT: usize = 2;
-    pub fn raw<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<RawHeader>,
-    {
-        self.raw = v.into();
+    pub fn raw(mut self, v: RawHeader) -> Self {
+        self.raw = v;
         self
     }
-    pub fn nonce<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint128>,
-    {
-        self.nonce = v.into();
+    pub fn nonce(mut self, v: Uint128) -> Self {
+        self.nonce = v;
         self
     }
 }
@@ -9003,25 +8016,19 @@ impl<'r> molecule::prelude::Reader<'r> for UncleBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct UncleBlockBuilder {
     pub(crate) header: Header,
     pub(crate) proposals: ProposalShortIdVec,
 }
 impl UncleBlockBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn proposals<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.proposals = v.into();
+    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
+        self.proposals = v;
         self
     }
 }
@@ -9311,7 +8318,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockBuilder {
     pub(crate) header: Header,
     pub(crate) uncles: UncleBlockVec,
@@ -9320,32 +8327,20 @@ pub struct BlockBuilder {
 }
 impl BlockBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn uncles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<UncleBlockVec>,
-    {
-        self.uncles = v.into();
+    pub fn uncles(mut self, v: UncleBlockVec) -> Self {
+        self.uncles = v;
         self
     }
-    pub fn transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<TransactionVec>,
-    {
-        self.transactions = v.into();
+    pub fn transactions(mut self, v: TransactionVec) -> Self {
+        self.transactions = v;
         self
     }
-    pub fn proposals<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.proposals = v.into();
+    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
+        self.proposals = v;
         self
     }
 }
@@ -9659,7 +8654,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockV1Builder {
     pub(crate) header: Header,
     pub(crate) uncles: UncleBlockVec,
@@ -9669,39 +8664,24 @@ pub struct BlockV1Builder {
 }
 impl BlockV1Builder {
     pub const FIELD_COUNT: usize = 5;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn uncles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<UncleBlockVec>,
-    {
-        self.uncles = v.into();
+    pub fn uncles(mut self, v: UncleBlockVec) -> Self {
+        self.uncles = v;
         self
     }
-    pub fn transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<TransactionVec>,
-    {
-        self.transactions = v.into();
+    pub fn transactions(mut self, v: TransactionVec) -> Self {
+        self.transactions = v;
         self
     }
-    pub fn proposals<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.proposals = v.into();
+    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
+        self.proposals = v;
         self
     }
-    pub fn extension<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.extension = v.into();
+    pub fn extension(mut self, v: Bytes) -> Self {
+        self.extension = v;
         self
     }
 }
@@ -9965,25 +8945,19 @@ impl<'r> molecule::prelude::Reader<'r> for CellbaseWitnessReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellbaseWitnessBuilder {
     pub(crate) lock: Script,
     pub(crate) message: Bytes,
 }
 impl CellbaseWitnessBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn lock<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Script>,
-    {
-        self.lock = v.into();
+    pub fn lock(mut self, v: Script) -> Self {
+        self.lock = v;
         self
     }
-    pub fn message<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.message = v.into();
+    pub fn message(mut self, v: Bytes) -> Self {
+        self.message = v;
         self
     }
 }
@@ -10247,7 +9221,7 @@ impl<'r> molecule::prelude::Reader<'r> for WitnessArgsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct WitnessArgsBuilder {
     pub(crate) lock: BytesOpt,
     pub(crate) input_type: BytesOpt,
@@ -10255,25 +9229,16 @@ pub struct WitnessArgsBuilder {
 }
 impl WitnessArgsBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn lock<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.lock = v.into();
+    pub fn lock(mut self, v: BytesOpt) -> Self {
+        self.lock = v;
         self
     }
-    pub fn input_type<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.input_type = v.into();
+    pub fn input_type(mut self, v: BytesOpt) -> Self {
+        self.input_type = v;
         self
     }
-    pub fn output_type<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.output_type = v.into();
+    pub fn output_type(mut self, v: BytesOpt) -> Self {
+        self.output_type = v;
         self
     }
 }
diff --git a/util/gen-types/src/generated/extensions.rs b/util/gen-types/src/generated/extensions.rs
index 1a37fc235e..c9066a2cc1 100644
--- a/util/gen-types/src/generated/extensions.rs
+++ b/util/gen-types/src/generated/extensions.rs
@@ -1,4 +1,4 @@
-// Generated by Molecule 0.8.0
+// Generated by Molecule 0.7.5
 
 use super::blockchain::*;
 use molecule::prelude::*;
@@ -136,14 +136,11 @@ impl<'r> molecule::prelude::Reader<'r> for BoolOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BoolOptBuilder(pub(crate) Option<Bool>);
 impl BoolOptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<Bool>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<Bool>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -169,11 +166,6 @@ impl molecule::prelude::Builder for BoolOptBuilder {
         BoolOpt::new_unchecked(inner.into())
     }
 }
-impl From<Bool> for BoolOpt {
-    fn from(value: Bool) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct Byte32Opt(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Byte32Opt {
@@ -308,14 +300,11 @@ impl<'r> molecule::prelude::Reader<'r> for Byte32OptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Byte32OptBuilder(pub(crate) Option<Byte32>);
 impl Byte32OptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<Byte32>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<Byte32>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -341,11 +330,6 @@ impl molecule::prelude::Builder for Byte32OptBuilder {
         Byte32Opt::new_unchecked(inner.into())
     }
 }
-impl From<Byte32> for Byte32Opt {
-    fn from(value: Byte32) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct Bool(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Bool {
@@ -470,7 +454,6 @@ impl<'r> molecule::prelude::Reader<'r> for BoolReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct BoolBuilder(pub(crate) [Byte; 1]);
 impl ::core::fmt::Debug for BoolBuilder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -486,18 +469,12 @@ impl BoolBuilder {
     pub const TOTAL_SIZE: usize = 1;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 1;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 1]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 1]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
 }
@@ -518,54 +495,6 @@ impl molecule::prelude::Builder for BoolBuilder {
         Bool::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 1usize]> for Bool {
-    fn from(value: [Byte; 1usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Bool {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 1usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Bool> for [Byte; 1usize] {
-    #[track_caller]
-    fn from(value: Bool) -> Self {
-        [value.nth0()]
-    }
-}
-impl From<[u8; 1usize]> for Bool {
-    fn from(value: [u8; 1usize]) -> Self {
-        BoolReader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Bool {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 1usize]>::try_from(value)?.into())
-    }
-}
-impl From<Bool> for [u8; 1usize] {
-    #[track_caller]
-    fn from(value: Bool) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<BoolReader<'a>> for &'a [u8; 1usize] {
-    #[track_caller]
-    fn from(value: BoolReader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a BoolReader<'a>> for &'a [u8; 1usize] {
-    #[track_caller]
-    fn from(value: &'a BoolReader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct BeUint32(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BeUint32 {
@@ -708,7 +637,6 @@ impl<'r> molecule::prelude::Reader<'r> for BeUint32Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct BeUint32Builder(pub(crate) [Byte; 4]);
 impl ::core::fmt::Debug for BeUint32Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -729,39 +657,24 @@ impl BeUint32Builder {
     pub const TOTAL_SIZE: usize = 4;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 4;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 4]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 4]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
 }
@@ -785,54 +698,6 @@ impl molecule::prelude::Builder for BeUint32Builder {
         BeUint32::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 4usize]> for BeUint32 {
-    fn from(value: [Byte; 4usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for BeUint32 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 4usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<BeUint32> for [Byte; 4usize] {
-    #[track_caller]
-    fn from(value: BeUint32) -> Self {
-        [value.nth0(), value.nth1(), value.nth2(), value.nth3()]
-    }
-}
-impl From<[u8; 4usize]> for BeUint32 {
-    fn from(value: [u8; 4usize]) -> Self {
-        BeUint32Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for BeUint32 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 4usize]>::try_from(value)?.into())
-    }
-}
-impl From<BeUint32> for [u8; 4usize] {
-    #[track_caller]
-    fn from(value: BeUint32) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<BeUint32Reader<'a>> for &'a [u8; 4usize] {
-    #[track_caller]
-    fn from(value: BeUint32Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a BeUint32Reader<'a>> for &'a [u8; 4usize] {
-    #[track_caller]
-    fn from(value: &'a BeUint32Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct BeUint64(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BeUint64 {
@@ -1008,7 +873,6 @@ impl<'r> molecule::prelude::Reader<'r> for BeUint64Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct BeUint64Builder(pub(crate) [Byte; 8]);
 impl ::core::fmt::Debug for BeUint64Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -1033,67 +897,40 @@ impl BeUint64Builder {
     pub const TOTAL_SIZE: usize = 8;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 8;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 8]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 8]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
-    pub fn nth2<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[2] = v.into();
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
         self
     }
-    pub fn nth3<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[3] = v.into();
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
         self
     }
-    pub fn nth4<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[4] = v.into();
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
         self
     }
-    pub fn nth5<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[5] = v.into();
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
         self
     }
-    pub fn nth6<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[6] = v.into();
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
         self
     }
-    pub fn nth7<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[7] = v.into();
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
         self
     }
 }
@@ -1121,63 +958,6 @@ impl molecule::prelude::Builder for BeUint64Builder {
         BeUint64::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 8usize]> for BeUint64 {
-    fn from(value: [Byte; 8usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for BeUint64 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 8usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<BeUint64> for [Byte; 8usize] {
-    #[track_caller]
-    fn from(value: BeUint64) -> Self {
-        [
-            value.nth0(),
-            value.nth1(),
-            value.nth2(),
-            value.nth3(),
-            value.nth4(),
-            value.nth5(),
-            value.nth6(),
-            value.nth7(),
-        ]
-    }
-}
-impl From<[u8; 8usize]> for BeUint64 {
-    fn from(value: [u8; 8usize]) -> Self {
-        BeUint64Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for BeUint64 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 8usize]>::try_from(value)?.into())
-    }
-}
-impl From<BeUint64> for [u8; 8usize] {
-    #[track_caller]
-    fn from(value: BeUint64) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<BeUint64Reader<'a>> for &'a [u8; 8usize] {
-    #[track_caller]
-    fn from(value: BeUint64Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a BeUint64Reader<'a>> for &'a [u8; 8usize] {
-    #[track_caller]
-    fn from(value: &'a BeUint64Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct Uint32Vec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint32Vec {
@@ -1357,7 +1137,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint32VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Uint32VecBuilder(pub(crate) Vec<Uint32>);
 impl Uint32VecBuilder {
     pub const ITEM_SIZE: usize = 4;
@@ -1365,24 +1145,20 @@ impl Uint32VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Uint32) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint32>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Uint32>
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
+    pub fn replace(&mut self, index: usize, v: Uint32) -> Option<Uint32> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for Uint32VecBuilder {
@@ -1454,16 +1230,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for Uint32VecReaderIterator<'t,
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Uint32> for Uint32Vec {
-    fn from_iter<T: IntoIterator<Item = Uint32>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Uint32>> for Uint32Vec {
-    fn from(v: Vec<Uint32>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Uint64Vec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint64Vec {
@@ -1643,7 +1409,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint64VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Uint64VecBuilder(pub(crate) Vec<Uint64>);
 impl Uint64VecBuilder {
     pub const ITEM_SIZE: usize = 8;
@@ -1651,24 +1417,20 @@ impl Uint64VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Uint64) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint64>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Uint64>
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
+    pub fn replace(&mut self, index: usize, v: Uint64) -> Option<Uint64> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for Uint64VecBuilder {
@@ -1740,16 +1502,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for Uint64VecReaderIterator<'t,
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Uint64> for Uint64Vec {
-    fn from_iter<T: IntoIterator<Item = Uint64>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Uint64>> for Uint64Vec {
-    fn from(v: Vec<Uint64>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Uint256Vec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint256Vec {
@@ -1929,7 +1681,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint256VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Uint256VecBuilder(pub(crate) Vec<Uint256>);
 impl Uint256VecBuilder {
     pub const ITEM_SIZE: usize = 32;
@@ -1937,24 +1689,20 @@ impl Uint256VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Uint256) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint256>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Uint256>
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
+    pub fn replace(&mut self, index: usize, v: Uint256) -> Option<Uint256> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for Uint256VecBuilder {
@@ -2026,16 +1774,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for Uint256VecReaderIterator<'t
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Uint256> for Uint256Vec {
-    fn from_iter<T: IntoIterator<Item = Uint256>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Uint256>> for Uint256Vec {
-    fn from(v: Vec<Uint256>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct CellOutputOpt(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for CellOutputOpt {
@@ -2170,14 +1908,11 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellOutputOptBuilder(pub(crate) Option<CellOutput>);
 impl CellOutputOptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<CellOutput>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<CellOutput>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -2203,11 +1938,6 @@ impl molecule::prelude::Builder for CellOutputOptBuilder {
         CellOutputOpt::new_unchecked(inner.into())
     }
 }
-impl From<CellOutput> for CellOutputOpt {
-    fn from(value: CellOutput) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct HeaderVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for HeaderVec {
@@ -2387,7 +2117,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct HeaderVecBuilder(pub(crate) Vec<Header>);
 impl HeaderVecBuilder {
     pub const ITEM_SIZE: usize = 208;
@@ -2395,24 +2125,20 @@ impl HeaderVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Header) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Header>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Header>
-    where
-        T: ::core::convert::Into<Header>,
-    {
+    pub fn replace(&mut self, index: usize, v: Header) -> Option<Header> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for HeaderVecBuilder {
@@ -2484,16 +2210,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for HeaderVecReaderIterator<'t,
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Header> for HeaderVec {
-    fn from_iter<T: IntoIterator<Item = Header>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Header>> for HeaderVec {
-    fn from(v: Vec<Header>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct OutPointVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for OutPointVec {
@@ -2673,7 +2389,7 @@ impl<'r> molecule::prelude::Reader<'r> for OutPointVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct OutPointVecBuilder(pub(crate) Vec<OutPoint>);
 impl OutPointVecBuilder {
     pub const ITEM_SIZE: usize = 36;
@@ -2681,24 +2397,20 @@ impl OutPointVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<OutPoint>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: OutPoint) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = OutPoint>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<OutPoint>
-    where
-        T: ::core::convert::Into<OutPoint>,
-    {
+    pub fn replace(&mut self, index: usize, v: OutPoint) -> Option<OutPoint> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for OutPointVecBuilder {
@@ -2770,16 +2482,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for OutPointVecReaderIterator<'
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<OutPoint> for OutPointVec {
-    fn from_iter<T: IntoIterator<Item = OutPoint>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<OutPoint>> for OutPointVec {
-    fn from(v: Vec<OutPoint>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Uint64VecOpt(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint64VecOpt {
@@ -2914,14 +2616,11 @@ impl<'r> molecule::prelude::Reader<'r> for Uint64VecOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Uint64VecOptBuilder(pub(crate) Option<Uint64Vec>);
 impl Uint64VecOptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<Uint64Vec>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<Uint64Vec>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -2947,11 +2646,6 @@ impl molecule::prelude::Builder for Uint64VecOptBuilder {
         Uint64VecOpt::new_unchecked(inner.into())
     }
 }
-impl From<Uint64Vec> for Uint64VecOpt {
-    fn from(value: Uint64Vec) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct HeaderDigest(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for HeaderDigest {
@@ -3177,7 +2871,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderDigestReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct HeaderDigestBuilder {
     pub(crate) children_hash: Byte32,
     pub(crate) total_difficulty: Uint256,
@@ -3194,74 +2888,44 @@ impl HeaderDigestBuilder {
     pub const TOTAL_SIZE: usize = 120;
     pub const FIELD_SIZES: [usize; 10] = [32, 32, 8, 8, 8, 8, 8, 8, 4, 4];
     pub const FIELD_COUNT: usize = 10;
-    pub fn children_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.children_hash = v.into();
+    pub fn children_hash(mut self, v: Byte32) -> Self {
+        self.children_hash = v;
         self
     }
-    pub fn total_difficulty<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
-        self.total_difficulty = v.into();
+    pub fn total_difficulty(mut self, v: Uint256) -> Self {
+        self.total_difficulty = v;
         self
     }
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
-    pub fn end_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.end_number = v.into();
+    pub fn end_number(mut self, v: Uint64) -> Self {
+        self.end_number = v;
         self
     }
-    pub fn start_epoch<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_epoch = v.into();
+    pub fn start_epoch(mut self, v: Uint64) -> Self {
+        self.start_epoch = v;
         self
     }
-    pub fn end_epoch<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.end_epoch = v.into();
+    pub fn end_epoch(mut self, v: Uint64) -> Self {
+        self.end_epoch = v;
         self
     }
-    pub fn start_timestamp<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_timestamp = v.into();
+    pub fn start_timestamp(mut self, v: Uint64) -> Self {
+        self.start_timestamp = v;
         self
     }
-    pub fn end_timestamp<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.end_timestamp = v.into();
+    pub fn end_timestamp(mut self, v: Uint64) -> Self {
+        self.end_timestamp = v;
         self
     }
-    pub fn start_compact_target<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.start_compact_target = v.into();
+    pub fn start_compact_target(mut self, v: Uint32) -> Self {
+        self.start_compact_target = v;
         self
     }
-    pub fn end_compact_target<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.end_compact_target = v.into();
+    pub fn end_compact_target(mut self, v: Uint32) -> Self {
+        self.end_compact_target = v;
         self
     }
 }
@@ -3426,7 +3090,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderViewReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct HeaderViewBuilder {
     pub(crate) hash: Byte32,
     pub(crate) data: Header,
@@ -3435,18 +3099,12 @@ impl HeaderViewBuilder {
     pub const TOTAL_SIZE: usize = 240;
     pub const FIELD_SIZES: [usize; 2] = [32, 208];
     pub const FIELD_COUNT: usize = 2;
-    pub fn hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.hash = v.into();
+    pub fn hash(mut self, v: Byte32) -> Self {
+        self.hash = v;
         self
     }
-    pub fn data<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.data = v.into();
+    pub fn data(mut self, v: Header) -> Self {
+        self.data = v;
         self
     }
 }
@@ -3682,25 +3340,19 @@ impl<'r> molecule::prelude::Reader<'r> for UncleBlockVecViewReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct UncleBlockVecViewBuilder {
     pub(crate) hashes: Byte32Vec,
     pub(crate) data: UncleBlockVec,
 }
 impl UncleBlockVecViewBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.hashes = v.into();
+    pub fn hashes(mut self, v: Byte32Vec) -> Self {
+        self.hashes = v;
         self
     }
-    pub fn data<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<UncleBlockVec>,
-    {
-        self.data = v.into();
+    pub fn data(mut self, v: UncleBlockVec) -> Self {
+        self.data = v;
         self
     }
 }
@@ -3971,7 +3623,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionViewReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct TransactionViewBuilder {
     pub(crate) hash: Byte32,
     pub(crate) witness_hash: Byte32,
@@ -3979,25 +3631,16 @@ pub struct TransactionViewBuilder {
 }
 impl TransactionViewBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.hash = v.into();
+    pub fn hash(mut self, v: Byte32) -> Self {
+        self.hash = v;
         self
     }
-    pub fn witness_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.witness_hash = v.into();
+    pub fn witness_hash(mut self, v: Byte32) -> Self {
+        self.witness_hash = v;
         self
     }
-    pub fn data<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Transaction>,
-    {
-        self.data = v.into();
+    pub fn data(mut self, v: Transaction) -> Self {
+        self.data = v;
         self
     }
 }
@@ -4311,7 +3954,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockExtReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockExtBuilder {
     pub(crate) total_difficulty: Uint256,
     pub(crate) total_uncles_count: Uint64,
@@ -4321,39 +3964,24 @@ pub struct BlockExtBuilder {
 }
 impl BlockExtBuilder {
     pub const FIELD_COUNT: usize = 5;
-    pub fn total_difficulty<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
-        self.total_difficulty = v.into();
+    pub fn total_difficulty(mut self, v: Uint256) -> Self {
+        self.total_difficulty = v;
         self
     }
-    pub fn total_uncles_count<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.total_uncles_count = v.into();
+    pub fn total_uncles_count(mut self, v: Uint64) -> Self {
+        self.total_uncles_count = v;
         self
     }
-    pub fn received_at<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.received_at = v.into();
+    pub fn received_at(mut self, v: Uint64) -> Self {
+        self.received_at = v;
         self
     }
-    pub fn txs_fees<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64Vec>,
-    {
-        self.txs_fees = v.into();
+    pub fn txs_fees(mut self, v: Uint64Vec) -> Self {
+        self.txs_fees = v;
         self
     }
-    pub fn verified<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BoolOpt>,
-    {
-        self.verified = v.into();
+    pub fn verified(mut self, v: BoolOpt) -> Self {
+        self.verified = v;
         self
     }
 }
@@ -4707,7 +4335,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockExtV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockExtV1Builder {
     pub(crate) total_difficulty: Uint256,
     pub(crate) total_uncles_count: Uint64,
@@ -4719,53 +4347,32 @@ pub struct BlockExtV1Builder {
 }
 impl BlockExtV1Builder {
     pub const FIELD_COUNT: usize = 7;
-    pub fn total_difficulty<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
-        self.total_difficulty = v.into();
+    pub fn total_difficulty(mut self, v: Uint256) -> Self {
+        self.total_difficulty = v;
         self
     }
-    pub fn total_uncles_count<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.total_uncles_count = v.into();
+    pub fn total_uncles_count(mut self, v: Uint64) -> Self {
+        self.total_uncles_count = v;
         self
     }
-    pub fn received_at<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.received_at = v.into();
+    pub fn received_at(mut self, v: Uint64) -> Self {
+        self.received_at = v;
         self
     }
-    pub fn txs_fees<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64Vec>,
-    {
-        self.txs_fees = v.into();
+    pub fn txs_fees(mut self, v: Uint64Vec) -> Self {
+        self.txs_fees = v;
         self
     }
-    pub fn verified<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BoolOpt>,
-    {
-        self.verified = v.into();
+    pub fn verified(mut self, v: BoolOpt) -> Self {
+        self.verified = v;
         self
     }
-    pub fn cycles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64VecOpt>,
-    {
-        self.cycles = v.into();
+    pub fn cycles(mut self, v: Uint64VecOpt) -> Self {
+        self.cycles = v;
         self
     }
-    pub fn txs_sizes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64VecOpt>,
-    {
-        self.txs_sizes = v.into();
+    pub fn txs_sizes(mut self, v: Uint64VecOpt) -> Self {
+        self.txs_sizes = v;
         self
     }
 }
@@ -5026,7 +4633,7 @@ impl<'r> molecule::prelude::Reader<'r> for EpochExtReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct EpochExtBuilder {
     pub(crate) previous_epoch_hash_rate: Uint256,
     pub(crate) last_block_hash_in_previous_epoch: Byte32,
@@ -5041,60 +4648,36 @@ impl EpochExtBuilder {
     pub const TOTAL_SIZE: usize = 108;
     pub const FIELD_SIZES: [usize; 8] = [32, 32, 4, 8, 8, 8, 8, 8];
     pub const FIELD_COUNT: usize = 8;
-    pub fn previous_epoch_hash_rate<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
-        self.previous_epoch_hash_rate = v.into();
+    pub fn previous_epoch_hash_rate(mut self, v: Uint256) -> Self {
+        self.previous_epoch_hash_rate = v;
         self
     }
-    pub fn last_block_hash_in_previous_epoch<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.last_block_hash_in_previous_epoch = v.into();
+    pub fn last_block_hash_in_previous_epoch(mut self, v: Byte32) -> Self {
+        self.last_block_hash_in_previous_epoch = v;
         self
     }
-    pub fn compact_target<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.compact_target = v.into();
+    pub fn compact_target(mut self, v: Uint32) -> Self {
+        self.compact_target = v;
         self
     }
-    pub fn number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.number = v.into();
+    pub fn number(mut self, v: Uint64) -> Self {
+        self.number = v;
         self
     }
-    pub fn base_block_reward<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.base_block_reward = v.into();
+    pub fn base_block_reward(mut self, v: Uint64) -> Self {
+        self.base_block_reward = v;
         self
     }
-    pub fn remainder_reward<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.remainder_reward = v.into();
+    pub fn remainder_reward(mut self, v: Uint64) -> Self {
+        self.remainder_reward = v;
         self
     }
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
-    pub fn length<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.length = v.into();
+    pub fn length(mut self, v: Uint64) -> Self {
+        self.length = v;
         self
     }
 }
@@ -5253,7 +4836,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionKeyReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct TransactionKeyBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) index: BeUint32,
@@ -5262,18 +4845,12 @@ impl TransactionKeyBuilder {
     pub const TOTAL_SIZE: usize = 36;
     pub const FIELD_SIZES: [usize; 2] = [32, 4];
     pub const FIELD_COUNT: usize = 2;
-    pub fn block_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.block_hash = v.into();
+    pub fn block_hash(mut self, v: Byte32) -> Self {
+        self.block_hash = v;
         self
     }
-    pub fn index<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BeUint32>,
-    {
-        self.index = v.into();
+    pub fn index(mut self, v: BeUint32) -> Self {
+        self.index = v;
         self
     }
 }
@@ -5426,7 +5003,7 @@ impl<'r> molecule::prelude::Reader<'r> for NumberHashReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct NumberHashBuilder {
     pub(crate) number: Uint64,
     pub(crate) block_hash: Byte32,
@@ -5435,18 +5012,12 @@ impl NumberHashBuilder {
     pub const TOTAL_SIZE: usize = 40;
     pub const FIELD_SIZES: [usize; 2] = [8, 32];
     pub const FIELD_COUNT: usize = 2;
-    pub fn number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.number = v.into();
+    pub fn number(mut self, v: Uint64) -> Self {
+        self.number = v;
         self
     }
-    pub fn block_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.block_hash = v.into();
+    pub fn block_hash(mut self, v: Byte32) -> Self {
+        self.block_hash = v;
         self
     }
 }
@@ -5608,7 +5179,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionInfoReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct TransactionInfoBuilder {
     pub(crate) block_number: Uint64,
     pub(crate) block_epoch: Uint64,
@@ -5618,25 +5189,16 @@ impl TransactionInfoBuilder {
     pub const TOTAL_SIZE: usize = 52;
     pub const FIELD_SIZES: [usize; 3] = [8, 8, 36];
     pub const FIELD_COUNT: usize = 3;
-    pub fn block_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.block_number = v.into();
+    pub fn block_number(mut self, v: Uint64) -> Self {
+        self.block_number = v;
         self
     }
-    pub fn block_epoch<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.block_epoch = v.into();
+    pub fn block_epoch(mut self, v: Uint64) -> Self {
+        self.block_epoch = v;
         self
     }
-    pub fn key<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<TransactionKey>,
-    {
-        self.key = v.into();
+    pub fn key(mut self, v: TransactionKey) -> Self {
+        self.key = v;
         self
     }
 }
@@ -5944,7 +5506,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellEntryReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellEntryBuilder {
     pub(crate) output: CellOutput,
     pub(crate) block_hash: Byte32,
@@ -5955,46 +5517,28 @@ pub struct CellEntryBuilder {
 }
 impl CellEntryBuilder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn output<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<CellOutput>,
-    {
-        self.output = v.into();
+    pub fn output(mut self, v: CellOutput) -> Self {
+        self.output = v;
         self
     }
-    pub fn block_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.block_hash = v.into();
+    pub fn block_hash(mut self, v: Byte32) -> Self {
+        self.block_hash = v;
         self
     }
-    pub fn block_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.block_number = v.into();
+    pub fn block_number(mut self, v: Uint64) -> Self {
+        self.block_number = v;
         self
     }
-    pub fn block_epoch<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.block_epoch = v.into();
+    pub fn block_epoch(mut self, v: Uint64) -> Self {
+        self.block_epoch = v;
         self
     }
-    pub fn index<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.index = v.into();
+    pub fn index(mut self, v: Uint32) -> Self {
+        self.index = v;
         self
     }
-    pub fn data_size<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.data_size = v.into();
+    pub fn data_size(mut self, v: Uint64) -> Self {
+        self.data_size = v;
         self
     }
 }
@@ -6261,25 +5805,19 @@ impl<'r> molecule::prelude::Reader<'r> for CellDataEntryReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CellDataEntryBuilder {
     pub(crate) output_data: Bytes,
     pub(crate) output_data_hash: Byte32,
 }
 impl CellDataEntryBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn output_data<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.output_data = v.into();
+    pub fn output_data(mut self, v: Bytes) -> Self {
+        self.output_data = v;
         self
     }
-    pub fn output_data_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.output_data_hash = v.into();
+    pub fn output_data_hash(mut self, v: Byte32) -> Self {
+        self.output_data_hash = v;
         self
     }
 }
@@ -6478,7 +6016,7 @@ impl<'r> molecule::prelude::Reader<'r> for RelayMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RelayMessageBuilder(pub(crate) RelayMessageUnion);
 impl RelayMessageBuilder {
     pub const ITEMS_COUNT: usize = 8;
@@ -6840,46 +6378,6 @@ impl<'r> RelayMessageUnionReader<'r> {
         }
     }
 }
-impl From<CompactBlock> for RelayMessage {
-    fn from(value: CompactBlock) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<RelayTransactions> for RelayMessage {
-    fn from(value: RelayTransactions) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<RelayTransactionHashes> for RelayMessage {
-    fn from(value: RelayTransactionHashes) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetRelayTransactions> for RelayMessage {
-    fn from(value: GetRelayTransactions) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetBlockTransactions> for RelayMessage {
-    fn from(value: GetBlockTransactions) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<BlockTransactions> for RelayMessage {
-    fn from(value: BlockTransactions) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetBlockProposal> for RelayMessage {
-    fn from(value: GetBlockProposal) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<BlockProposal> for RelayMessage {
-    fn from(value: BlockProposal) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
 #[derive(Clone)]
 pub struct CompactBlock(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for CompactBlock {
@@ -7162,7 +6660,7 @@ impl<'r> molecule::prelude::Reader<'r> for CompactBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CompactBlockBuilder {
     pub(crate) header: Header,
     pub(crate) short_ids: ProposalShortIdVec,
@@ -7172,39 +6670,24 @@ pub struct CompactBlockBuilder {
 }
 impl CompactBlockBuilder {
     pub const FIELD_COUNT: usize = 5;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn short_ids<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.short_ids = v.into();
+    pub fn short_ids(mut self, v: ProposalShortIdVec) -> Self {
+        self.short_ids = v;
         self
     }
-    pub fn prefilled_transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<IndexTransactionVec>,
-    {
-        self.prefilled_transactions = v.into();
+    pub fn prefilled_transactions(mut self, v: IndexTransactionVec) -> Self {
+        self.prefilled_transactions = v;
         self
     }
-    pub fn uncles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.uncles = v.into();
+    pub fn uncles(mut self, v: Byte32Vec) -> Self {
+        self.uncles = v;
         self
     }
-    pub fn proposals<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.proposals = v.into();
+    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
+        self.proposals = v;
         self
     }
 }
@@ -7548,7 +7031,7 @@ impl<'r> molecule::prelude::Reader<'r> for CompactBlockV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CompactBlockV1Builder {
     pub(crate) header: Header,
     pub(crate) short_ids: ProposalShortIdVec,
@@ -7559,46 +7042,28 @@ pub struct CompactBlockV1Builder {
 }
 impl CompactBlockV1Builder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn short_ids<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.short_ids = v.into();
+    pub fn short_ids(mut self, v: ProposalShortIdVec) -> Self {
+        self.short_ids = v;
         self
     }
-    pub fn prefilled_transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<IndexTransactionVec>,
-    {
-        self.prefilled_transactions = v.into();
+    pub fn prefilled_transactions(mut self, v: IndexTransactionVec) -> Self {
+        self.prefilled_transactions = v;
         self
     }
-    pub fn uncles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.uncles = v.into();
+    pub fn uncles(mut self, v: Byte32Vec) -> Self {
+        self.uncles = v;
         self
     }
-    pub fn proposals<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.proposals = v.into();
+    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
+        self.proposals = v;
         self
     }
-    pub fn extension<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.extension = v.into();
+    pub fn extension(mut self, v: Bytes) -> Self {
+        self.extension = v;
         self
     }
 }
@@ -7867,25 +7332,19 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RelayTransactionBuilder {
     pub(crate) cycles: Uint64,
     pub(crate) transaction: Transaction,
 }
 impl RelayTransactionBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn cycles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.cycles = v.into();
+    pub fn cycles(mut self, v: Uint64) -> Self {
+        self.cycles = v;
         self
     }
-    pub fn transaction<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Transaction>,
-    {
-        self.transaction = v.into();
+    pub fn transaction(mut self, v: Transaction) -> Self {
+        self.transaction = v;
         self
     }
 }
@@ -8142,34 +7601,30 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RelayTransactionVecBuilder(pub(crate) Vec<RelayTransaction>);
 impl RelayTransactionVecBuilder {
     pub fn set(mut self, v: Vec<RelayTransaction>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<RelayTransaction>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: RelayTransaction) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = RelayTransaction>>(
         mut self,
         iter: T,
     ) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<RelayTransaction>
-    where
-        T: ::core::convert::Into<RelayTransaction>,
-    {
+    pub fn replace(&mut self, index: usize, v: RelayTransaction) -> Option<RelayTransaction> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for RelayTransactionVecBuilder {
@@ -8270,16 +7725,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for RelayTransactionVecReaderIt
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<RelayTransaction> for RelayTransactionVec {
-    fn from_iter<T: IntoIterator<Item = RelayTransaction>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<RelayTransaction>> for RelayTransactionVec {
-    fn from(v: Vec<RelayTransaction>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct RelayTransactions(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for RelayTransactions {
@@ -8477,17 +7922,14 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RelayTransactionsBuilder {
     pub(crate) transactions: RelayTransactionVec,
 }
 impl RelayTransactionsBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<RelayTransactionVec>,
-    {
-        self.transactions = v.into();
+    pub fn transactions(mut self, v: RelayTransactionVec) -> Self {
+        self.transactions = v;
         self
     }
 }
@@ -8713,17 +8155,14 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionHashesReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RelayTransactionHashesBuilder {
     pub(crate) tx_hashes: Byte32Vec,
 }
 impl RelayTransactionHashesBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn tx_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.tx_hashes = v.into();
+    pub fn tx_hashes(mut self, v: Byte32Vec) -> Self {
+        self.tx_hashes = v;
         self
     }
 }
@@ -8949,17 +8388,14 @@ impl<'r> molecule::prelude::Reader<'r> for GetRelayTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetRelayTransactionsBuilder {
     pub(crate) tx_hashes: Byte32Vec,
 }
 impl GetRelayTransactionsBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn tx_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.tx_hashes = v.into();
+    pub fn tx_hashes(mut self, v: Byte32Vec) -> Self {
+        self.tx_hashes = v;
         self
     }
 }
@@ -9221,7 +8657,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlockTransactionsBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) indexes: Uint32Vec,
@@ -9229,25 +8665,16 @@ pub struct GetBlockTransactionsBuilder {
 }
 impl GetBlockTransactionsBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn block_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.block_hash = v.into();
+    pub fn block_hash(mut self, v: Byte32) -> Self {
+        self.block_hash = v;
         self
     }
-    pub fn indexes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32Vec>,
-    {
-        self.indexes = v.into();
+    pub fn indexes(mut self, v: Uint32Vec) -> Self {
+        self.indexes = v;
         self
     }
-    pub fn uncle_indexes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32Vec>,
-    {
-        self.uncle_indexes = v.into();
+    pub fn uncle_indexes(mut self, v: Uint32Vec) -> Self {
+        self.uncle_indexes = v;
         self
     }
 }
@@ -9518,7 +8945,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockTransactionsBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) transactions: TransactionVec,
@@ -9526,25 +8953,16 @@ pub struct BlockTransactionsBuilder {
 }
 impl BlockTransactionsBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn block_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.block_hash = v.into();
+    pub fn block_hash(mut self, v: Byte32) -> Self {
+        self.block_hash = v;
         self
     }
-    pub fn transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<TransactionVec>,
-    {
-        self.transactions = v.into();
+    pub fn transactions(mut self, v: TransactionVec) -> Self {
+        self.transactions = v;
         self
     }
-    pub fn uncles<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<UncleBlockVec>,
-    {
-        self.uncles = v.into();
+    pub fn uncles(mut self, v: UncleBlockVec) -> Self {
+        self.uncles = v;
         self
     }
 }
@@ -9799,25 +9217,19 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockProposalReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlockProposalBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) proposals: ProposalShortIdVec,
 }
 impl GetBlockProposalBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn block_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.block_hash = v.into();
+    pub fn block_hash(mut self, v: Byte32) -> Self {
+        self.block_hash = v;
         self
     }
-    pub fn proposals<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<ProposalShortIdVec>,
-    {
-        self.proposals = v.into();
+    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
+        self.proposals = v;
         self
     }
 }
@@ -10048,17 +9460,14 @@ impl<'r> molecule::prelude::Reader<'r> for BlockProposalReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockProposalBuilder {
     pub(crate) transactions: TransactionVec,
 }
 impl BlockProposalBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<TransactionVec>,
-    {
-        self.transactions = v.into();
+    pub fn transactions(mut self, v: TransactionVec) -> Self {
+        self.transactions = v;
         self
     }
 }
@@ -10305,25 +9714,19 @@ impl<'r> molecule::prelude::Reader<'r> for IndexTransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct IndexTransactionBuilder {
     pub(crate) index: Uint32,
     pub(crate) transaction: Transaction,
 }
 impl IndexTransactionBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn index<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.index = v.into();
+    pub fn index(mut self, v: Uint32) -> Self {
+        self.index = v;
         self
     }
-    pub fn transaction<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Transaction>,
-    {
-        self.transaction = v.into();
+    pub fn transaction(mut self, v: Transaction) -> Self {
+        self.transaction = v;
         self
     }
 }
@@ -10580,34 +9983,30 @@ impl<'r> molecule::prelude::Reader<'r> for IndexTransactionVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct IndexTransactionVecBuilder(pub(crate) Vec<IndexTransaction>);
 impl IndexTransactionVecBuilder {
     pub fn set(mut self, v: Vec<IndexTransaction>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<IndexTransaction>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: IndexTransaction) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = IndexTransaction>>(
         mut self,
         iter: T,
     ) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<IndexTransaction>
-    where
-        T: ::core::convert::Into<IndexTransaction>,
-    {
+    pub fn replace(&mut self, index: usize, v: IndexTransaction) -> Option<IndexTransaction> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for IndexTransactionVecBuilder {
@@ -10708,16 +10107,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for IndexTransactionVecReaderIt
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<IndexTransaction> for IndexTransactionVec {
-    fn from_iter<T: IntoIterator<Item = IndexTransaction>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<IndexTransaction>> for IndexTransactionVec {
-    fn from(v: Vec<IndexTransaction>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct BlockFilterMessage(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for BlockFilterMessage {
@@ -10867,7 +10256,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFilterMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockFilterMessageBuilder(pub(crate) BlockFilterMessageUnion);
 impl BlockFilterMessageBuilder {
     pub const ITEMS_COUNT: usize = 6;
@@ -11185,36 +10574,6 @@ impl<'r> BlockFilterMessageUnionReader<'r> {
         }
     }
 }
-impl From<GetBlockFilters> for BlockFilterMessage {
-    fn from(value: GetBlockFilters) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<BlockFilters> for BlockFilterMessage {
-    fn from(value: BlockFilters) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetBlockFilterHashes> for BlockFilterMessage {
-    fn from(value: GetBlockFilterHashes) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<BlockFilterHashes> for BlockFilterMessage {
-    fn from(value: BlockFilterHashes) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetBlockFilterCheckPoints> for BlockFilterMessage {
-    fn from(value: GetBlockFilterCheckPoints) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<BlockFilterCheckPoints> for BlockFilterMessage {
-    fn from(value: BlockFilterCheckPoints) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
 #[derive(Clone)]
 pub struct GetBlockFilters(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for GetBlockFilters {
@@ -11333,7 +10692,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockFiltersReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlockFiltersBuilder {
     pub(crate) start_number: Uint64,
 }
@@ -11341,11 +10700,8 @@ impl GetBlockFiltersBuilder {
     pub const TOTAL_SIZE: usize = 8;
     pub const FIELD_SIZES: [usize; 1] = [8];
     pub const FIELD_COUNT: usize = 1;
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
 }
@@ -11599,7 +10955,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFiltersReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockFiltersBuilder {
     pub(crate) start_number: Uint64,
     pub(crate) block_hashes: Byte32Vec,
@@ -11607,25 +10963,16 @@ pub struct BlockFiltersBuilder {
 }
 impl BlockFiltersBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
-    pub fn block_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.block_hashes = v.into();
+    pub fn block_hashes(mut self, v: Byte32Vec) -> Self {
+        self.block_hashes = v;
         self
     }
-    pub fn filters<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesVec>,
-    {
-        self.filters = v.into();
+    pub fn filters(mut self, v: BytesVec) -> Self {
+        self.filters = v;
         self
     }
 }
@@ -11781,7 +11128,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockFilterHashesReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlockFilterHashesBuilder {
     pub(crate) start_number: Uint64,
 }
@@ -11789,11 +11136,8 @@ impl GetBlockFilterHashesBuilder {
     pub const TOTAL_SIZE: usize = 8;
     pub const FIELD_SIZES: [usize; 1] = [8];
     pub const FIELD_COUNT: usize = 1;
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
 }
@@ -12068,7 +11412,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFilterHashesReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockFilterHashesBuilder {
     pub(crate) start_number: Uint64,
     pub(crate) parent_block_filter_hash: Byte32,
@@ -12076,25 +11420,16 @@ pub struct BlockFilterHashesBuilder {
 }
 impl BlockFilterHashesBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
-    pub fn parent_block_filter_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.parent_block_filter_hash = v.into();
+    pub fn parent_block_filter_hash(mut self, v: Byte32) -> Self {
+        self.parent_block_filter_hash = v;
         self
     }
-    pub fn block_filter_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.block_filter_hashes = v.into();
+    pub fn block_filter_hashes(mut self, v: Byte32Vec) -> Self {
+        self.block_filter_hashes = v;
         self
     }
 }
@@ -12251,7 +11586,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockFilterCheckPointsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlockFilterCheckPointsBuilder {
     pub(crate) start_number: Uint64,
 }
@@ -12259,11 +11594,8 @@ impl GetBlockFilterCheckPointsBuilder {
     pub const TOTAL_SIZE: usize = 8;
     pub const FIELD_SIZES: [usize; 1] = [8];
     pub const FIELD_COUNT: usize = 1;
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
 }
@@ -12510,25 +11842,19 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFilterCheckPointsReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct BlockFilterCheckPointsBuilder {
     pub(crate) start_number: Uint64,
     pub(crate) block_filter_hashes: Byte32Vec,
 }
 impl BlockFilterCheckPointsBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
-    pub fn block_filter_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.block_filter_hashes = v.into();
+    pub fn block_filter_hashes(mut self, v: Byte32Vec) -> Self {
+        self.block_filter_hashes = v;
         self
     }
 }
@@ -12711,7 +12037,7 @@ impl<'r> molecule::prelude::Reader<'r> for SyncMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SyncMessageBuilder(pub(crate) SyncMessageUnion);
 impl SyncMessageBuilder {
     pub const ITEMS_COUNT: usize = 5;
@@ -12953,31 +12279,6 @@ impl<'r> SyncMessageUnionReader<'r> {
         }
     }
 }
-impl From<GetHeaders> for SyncMessage {
-    fn from(value: GetHeaders) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<SendHeaders> for SyncMessage {
-    fn from(value: SendHeaders) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetBlocks> for SyncMessage {
-    fn from(value: GetBlocks) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<SendBlock> for SyncMessage {
-    fn from(value: SendBlock) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<InIBD> for SyncMessage {
-    fn from(value: InIBD) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
 #[derive(Clone)]
 pub struct GetHeaders(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for GetHeaders {
@@ -13205,25 +12506,19 @@ impl<'r> molecule::prelude::Reader<'r> for GetHeadersReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetHeadersBuilder {
     pub(crate) hash_stop: Byte32,
     pub(crate) block_locator_hashes: Byte32Vec,
 }
 impl GetHeadersBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn hash_stop<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.hash_stop = v.into();
+    pub fn hash_stop(mut self, v: Byte32) -> Self {
+        self.hash_stop = v;
         self
     }
-    pub fn block_locator_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.block_locator_hashes = v.into();
+    pub fn block_locator_hashes(mut self, v: Byte32Vec) -> Self {
+        self.block_locator_hashes = v;
         self
     }
 }
@@ -13454,17 +12749,14 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlocksReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlocksBuilder {
     pub(crate) block_hashes: Byte32Vec,
 }
 impl GetBlocksBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn block_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.block_hashes = v.into();
+    pub fn block_hashes(mut self, v: Byte32Vec) -> Self {
+        self.block_hashes = v;
         self
     }
 }
@@ -13690,17 +12982,14 @@ impl<'r> molecule::prelude::Reader<'r> for SendHeadersReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendHeadersBuilder {
     pub(crate) headers: HeaderVec,
 }
 impl SendHeadersBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn headers<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderVec>,
-    {
-        self.headers = v.into();
+    pub fn headers(mut self, v: HeaderVec) -> Self {
+        self.headers = v;
         self
     }
 }
@@ -13936,17 +13225,14 @@ impl<'r> molecule::prelude::Reader<'r> for SendBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendBlockBuilder {
     pub(crate) block: Block,
 }
 impl SendBlockBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn block<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Block>,
-    {
-        self.block = v.into();
+    pub fn block(mut self, v: Block) -> Self {
+        self.block = v;
         self
     }
 }
@@ -14232,7 +13518,7 @@ impl<'r> molecule::prelude::Reader<'r> for FilteredBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct FilteredBlockBuilder {
     pub(crate) header: Header,
     pub(crate) witnesses_root: Byte32,
@@ -14241,32 +13527,20 @@ pub struct FilteredBlockBuilder {
 }
 impl FilteredBlockBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn witnesses_root<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.witnesses_root = v.into();
+    pub fn witnesses_root(mut self, v: Byte32) -> Self {
+        self.witnesses_root = v;
         self
     }
-    pub fn transactions<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<TransactionVec>,
-    {
-        self.transactions = v.into();
+    pub fn transactions(mut self, v: TransactionVec) -> Self {
+        self.transactions = v;
         self
     }
-    pub fn proof<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<MerkleProof>,
-    {
-        self.proof = v.into();
+    pub fn proof(mut self, v: MerkleProof) -> Self {
+        self.proof = v;
         self
     }
 }
@@ -14524,25 +13798,19 @@ impl<'r> molecule::prelude::Reader<'r> for MerkleProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct MerkleProofBuilder {
     pub(crate) indices: Uint32Vec,
     pub(crate) lemmas: Byte32Vec,
 }
 impl MerkleProofBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn indices<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32Vec>,
-    {
-        self.indices = v.into();
+    pub fn indices(mut self, v: Uint32Vec) -> Self {
+        self.indices = v;
         self
     }
-    pub fn lemmas<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.lemmas = v.into();
+    pub fn lemmas(mut self, v: Byte32Vec) -> Self {
+        self.lemmas = v;
         self
     }
 }
@@ -14729,7 +13997,7 @@ impl<'r> molecule::prelude::Reader<'r> for InIBDReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct InIBDBuilder {}
 impl InIBDBuilder {
     pub const FIELD_COUNT: usize = 0;
@@ -14932,7 +14200,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderDigestVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct HeaderDigestVecBuilder(pub(crate) Vec<HeaderDigest>);
 impl HeaderDigestVecBuilder {
     pub const ITEM_SIZE: usize = 120;
@@ -14940,24 +14208,20 @@ impl HeaderDigestVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigest>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: HeaderDigest) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = HeaderDigest>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<HeaderDigest>
-    where
-        T: ::core::convert::Into<HeaderDigest>,
-    {
+    pub fn replace(&mut self, index: usize, v: HeaderDigest) -> Option<HeaderDigest> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for HeaderDigestVecBuilder {
@@ -15029,16 +14293,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for HeaderDigestVecReaderIterat
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<HeaderDigest> for HeaderDigestVec {
-    fn from_iter<T: IntoIterator<Item = HeaderDigest>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<HeaderDigest>> for HeaderDigestVec {
-    fn from(v: Vec<HeaderDigest>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct VerifiableHeader(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for VerifiableHeader {
@@ -15299,7 +14553,7 @@ impl<'r> molecule::prelude::Reader<'r> for VerifiableHeaderReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct VerifiableHeaderBuilder {
     pub(crate) header: Header,
     pub(crate) uncles_hash: Byte32,
@@ -15308,32 +14562,20 @@ pub struct VerifiableHeaderBuilder {
 }
 impl VerifiableHeaderBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Header>,
-    {
-        self.header = v.into();
+    pub fn header(mut self, v: Header) -> Self {
+        self.header = v;
         self
     }
-    pub fn uncles_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.uncles_hash = v.into();
+    pub fn uncles_hash(mut self, v: Byte32) -> Self {
+        self.uncles_hash = v;
         self
     }
-    pub fn extension<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.extension = v.into();
+    pub fn extension(mut self, v: BytesOpt) -> Self {
+        self.extension = v;
         self
     }
-    pub fn parent_chain_root<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigest>,
-    {
-        self.parent_chain_root = v.into();
+    pub fn parent_chain_root(mut self, v: HeaderDigest) -> Self {
+        self.parent_chain_root = v;
         self
     }
 }
@@ -15598,34 +14840,30 @@ impl<'r> molecule::prelude::Reader<'r> for VerifiableHeaderVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct VerifiableHeaderVecBuilder(pub(crate) Vec<VerifiableHeader>);
 impl VerifiableHeaderVecBuilder {
     pub fn set(mut self, v: Vec<VerifiableHeader>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: VerifiableHeader) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = VerifiableHeader>>(
         mut self,
         iter: T,
     ) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<VerifiableHeader>
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
+    pub fn replace(&mut self, index: usize, v: VerifiableHeader) -> Option<VerifiableHeader> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for VerifiableHeaderVecBuilder {
@@ -15726,16 +14964,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for VerifiableHeaderVecReaderIt
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<VerifiableHeader> for VerifiableHeaderVec {
-    fn from_iter<T: IntoIterator<Item = VerifiableHeader>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<VerifiableHeader>> for VerifiableHeaderVec {
-    fn from(v: Vec<VerifiableHeader>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct FilteredBlockVec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for FilteredBlockVec {
@@ -15959,31 +15187,27 @@ impl<'r> molecule::prelude::Reader<'r> for FilteredBlockVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct FilteredBlockVecBuilder(pub(crate) Vec<FilteredBlock>);
 impl FilteredBlockVecBuilder {
     pub fn set(mut self, v: Vec<FilteredBlock>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<FilteredBlock>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: FilteredBlock) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = FilteredBlock>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<FilteredBlock>
-    where
-        T: ::core::convert::Into<FilteredBlock>,
-    {
+    pub fn replace(&mut self, index: usize, v: FilteredBlock) -> Option<FilteredBlock> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for FilteredBlockVecBuilder {
@@ -16080,16 +15304,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for FilteredBlockVecReaderItera
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<FilteredBlock> for FilteredBlockVec {
-    fn from_iter<T: IntoIterator<Item = FilteredBlock>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<FilteredBlock>> for FilteredBlockVec {
-    fn from(v: Vec<FilteredBlock>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct LightClientMessage(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for LightClientMessage {
@@ -16245,7 +15459,7 @@ impl<'r> molecule::prelude::Reader<'r> for LightClientMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct LightClientMessageBuilder(pub(crate) LightClientMessageUnion);
 impl LightClientMessageBuilder {
     pub const ITEMS_COUNT: usize = 8;
@@ -16599,46 +15813,6 @@ impl<'r> LightClientMessageUnionReader<'r> {
         }
     }
 }
-impl From<GetLastState> for LightClientMessage {
-    fn from(value: GetLastState) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<SendLastState> for LightClientMessage {
-    fn from(value: SendLastState) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetLastStateProof> for LightClientMessage {
-    fn from(value: GetLastStateProof) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<SendLastStateProof> for LightClientMessage {
-    fn from(value: SendLastStateProof) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetBlocksProof> for LightClientMessage {
-    fn from(value: GetBlocksProof) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<SendBlocksProof> for LightClientMessage {
-    fn from(value: SendBlocksProof) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<GetTransactionsProof> for LightClientMessage {
-    fn from(value: GetTransactionsProof) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<SendTransactionsProof> for LightClientMessage {
-    fn from(value: SendTransactionsProof) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
 #[derive(Clone)]
 pub struct GetLastState(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for GetLastState {
@@ -16836,17 +16010,14 @@ impl<'r> molecule::prelude::Reader<'r> for GetLastStateReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetLastStateBuilder {
     pub(crate) subscribe: Bool,
 }
 impl GetLastStateBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn subscribe<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bool>,
-    {
-        self.subscribe = v.into();
+    pub fn subscribe(mut self, v: Bool) -> Self {
+        self.subscribe = v;
         self
     }
 }
@@ -17086,17 +16257,14 @@ impl<'r> molecule::prelude::Reader<'r> for SendLastStateReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendLastStateBuilder {
     pub(crate) last_header: VerifiableHeader,
 }
 impl SendLastStateBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn last_header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.last_header = v.into();
+    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
+        self.last_header = v;
         self
     }
 }
@@ -17419,7 +16587,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetLastStateProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetLastStateProofBuilder {
     pub(crate) last_hash: Byte32,
     pub(crate) start_hash: Byte32,
@@ -17430,46 +16598,28 @@ pub struct GetLastStateProofBuilder {
 }
 impl GetLastStateProofBuilder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn last_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.last_hash = v.into();
+    pub fn last_hash(mut self, v: Byte32) -> Self {
+        self.last_hash = v;
         self
     }
-    pub fn start_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.start_hash = v.into();
+    pub fn start_hash(mut self, v: Byte32) -> Self {
+        self.start_hash = v;
         self
     }
-    pub fn start_number<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.start_number = v.into();
+    pub fn start_number(mut self, v: Uint64) -> Self {
+        self.start_number = v;
         self
     }
-    pub fn last_n_blocks<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.last_n_blocks = v.into();
+    pub fn last_n_blocks(mut self, v: Uint64) -> Self {
+        self.last_n_blocks = v;
         self
     }
-    pub fn difficulty_boundary<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256>,
-    {
-        self.difficulty_boundary = v.into();
+    pub fn difficulty_boundary(mut self, v: Uint256) -> Self {
+        self.difficulty_boundary = v;
         self
     }
-    pub fn difficulties<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint256Vec>,
-    {
-        self.difficulties = v.into();
+    pub fn difficulties(mut self, v: Uint256Vec) -> Self {
+        self.difficulties = v;
         self
     }
 }
@@ -17764,7 +16914,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendLastStateProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendLastStateProofBuilder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -17772,25 +16922,16 @@ pub struct SendLastStateProofBuilder {
 }
 impl SendLastStateProofBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn last_header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.last_header = v.into();
+    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
+        self.last_header = v;
         self
     }
-    pub fn proof<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigestVec>,
-    {
-        self.proof = v.into();
+    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
+        self.proof = v;
         self
     }
-    pub fn headers<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeaderVec>,
-    {
-        self.headers = v.into();
+    pub fn headers(mut self, v: VerifiableHeaderVec) -> Self {
+        self.headers = v;
         self
     }
 }
@@ -18045,25 +17186,19 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlocksProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetBlocksProofBuilder {
     pub(crate) last_hash: Byte32,
     pub(crate) block_hashes: Byte32Vec,
 }
 impl GetBlocksProofBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn last_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.last_hash = v.into();
+    pub fn last_hash(mut self, v: Byte32) -> Self {
+        self.last_hash = v;
         self
     }
-    pub fn block_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.block_hashes = v.into();
+    pub fn block_hashes(mut self, v: Byte32Vec) -> Self {
+        self.block_hashes = v;
         self
     }
 }
@@ -18368,7 +17503,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendBlocksProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendBlocksProofBuilder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -18377,32 +17512,20 @@ pub struct SendBlocksProofBuilder {
 }
 impl SendBlocksProofBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn last_header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.last_header = v.into();
+    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
+        self.last_header = v;
         self
     }
-    pub fn proof<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigestVec>,
-    {
-        self.proof = v.into();
+    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
+        self.proof = v;
         self
     }
-    pub fn headers<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderVec>,
-    {
-        self.headers = v.into();
+    pub fn headers(mut self, v: HeaderVec) -> Self {
+        self.headers = v;
         self
     }
-    pub fn missing_block_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.missing_block_hashes = v.into();
+    pub fn missing_block_hashes(mut self, v: Byte32Vec) -> Self {
+        self.missing_block_hashes = v;
         self
     }
 }
@@ -18758,7 +17881,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendBlocksProofV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendBlocksProofV1Builder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -18769,46 +17892,28 @@ pub struct SendBlocksProofV1Builder {
 }
 impl SendBlocksProofV1Builder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn last_header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.last_header = v.into();
+    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
+        self.last_header = v;
         self
     }
-    pub fn proof<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigestVec>,
-    {
-        self.proof = v.into();
+    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
+        self.proof = v;
         self
     }
-    pub fn headers<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderVec>,
-    {
-        self.headers = v.into();
+    pub fn headers(mut self, v: HeaderVec) -> Self {
+        self.headers = v;
         self
     }
-    pub fn missing_block_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.missing_block_hashes = v.into();
+    pub fn missing_block_hashes(mut self, v: Byte32Vec) -> Self {
+        self.missing_block_hashes = v;
         self
     }
-    pub fn blocks_uncles_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.blocks_uncles_hash = v.into();
+    pub fn blocks_uncles_hash(mut self, v: Byte32Vec) -> Self {
+        self.blocks_uncles_hash = v;
         self
     }
-    pub fn blocks_extension<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOptVec>,
-    {
-        self.blocks_extension = v.into();
+    pub fn blocks_extension(mut self, v: BytesOptVec) -> Self {
+        self.blocks_extension = v;
         self
     }
 }
@@ -19075,25 +18180,19 @@ impl<'r> molecule::prelude::Reader<'r> for GetTransactionsProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetTransactionsProofBuilder {
     pub(crate) last_hash: Byte32,
     pub(crate) tx_hashes: Byte32Vec,
 }
 impl GetTransactionsProofBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn last_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32>,
-    {
-        self.last_hash = v.into();
+    pub fn last_hash(mut self, v: Byte32) -> Self {
+        self.last_hash = v;
         self
     }
-    pub fn tx_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.tx_hashes = v.into();
+    pub fn tx_hashes(mut self, v: Byte32Vec) -> Self {
+        self.tx_hashes = v;
         self
     }
 }
@@ -19388,7 +18487,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendTransactionsProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendTransactionsProofBuilder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -19397,32 +18496,20 @@ pub struct SendTransactionsProofBuilder {
 }
 impl SendTransactionsProofBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn last_header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.last_header = v.into();
+    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
+        self.last_header = v;
         self
     }
-    pub fn proof<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigestVec>,
-    {
-        self.proof = v.into();
+    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
+        self.proof = v;
         self
     }
-    pub fn filtered_blocks<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<FilteredBlockVec>,
-    {
-        self.filtered_blocks = v.into();
+    pub fn filtered_blocks(mut self, v: FilteredBlockVec) -> Self {
+        self.filtered_blocks = v;
         self
     }
-    pub fn missing_tx_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.missing_tx_hashes = v.into();
+    pub fn missing_tx_hashes(mut self, v: Byte32Vec) -> Self {
+        self.missing_tx_hashes = v;
         self
     }
 }
@@ -19768,7 +18855,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendTransactionsProofV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct SendTransactionsProofV1Builder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -19779,46 +18866,28 @@ pub struct SendTransactionsProofV1Builder {
 }
 impl SendTransactionsProofV1Builder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn last_header<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<VerifiableHeader>,
-    {
-        self.last_header = v.into();
+    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
+        self.last_header = v;
         self
     }
-    pub fn proof<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<HeaderDigestVec>,
-    {
-        self.proof = v.into();
+    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
+        self.proof = v;
         self
     }
-    pub fn filtered_blocks<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<FilteredBlockVec>,
-    {
-        self.filtered_blocks = v.into();
+    pub fn filtered_blocks(mut self, v: FilteredBlockVec) -> Self {
+        self.filtered_blocks = v;
         self
     }
-    pub fn missing_tx_hashes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.missing_tx_hashes = v.into();
+    pub fn missing_tx_hashes(mut self, v: Byte32Vec) -> Self {
+        self.missing_tx_hashes = v;
         self
     }
-    pub fn blocks_uncles_hash<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte32Vec>,
-    {
-        self.blocks_uncles_hash = v.into();
+    pub fn blocks_uncles_hash(mut self, v: Byte32Vec) -> Self {
+        self.blocks_uncles_hash = v;
         self
     }
-    pub fn blocks_extension<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOptVec>,
-    {
-        self.blocks_extension = v.into();
+    pub fn blocks_extension(mut self, v: BytesOptVec) -> Self {
+        self.blocks_extension = v;
         self
     }
 }
@@ -20065,17 +19134,14 @@ impl<'r> molecule::prelude::Reader<'r> for TimeReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct TimeBuilder {
     pub(crate) timestamp: Uint64,
 }
 impl TimeBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn timestamp<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.timestamp = v.into();
+    pub fn timestamp(mut self, v: Uint64) -> Self {
+        self.timestamp = v;
         self
     }
 }
@@ -20401,7 +19467,7 @@ impl<'r> molecule::prelude::Reader<'r> for RawAlertReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct RawAlertBuilder {
     pub(crate) notice_until: Uint64,
     pub(crate) id: Uint32,
@@ -20413,53 +19479,32 @@ pub struct RawAlertBuilder {
 }
 impl RawAlertBuilder {
     pub const FIELD_COUNT: usize = 7;
-    pub fn notice_until<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.notice_until = v.into();
+    pub fn notice_until(mut self, v: Uint64) -> Self {
+        self.notice_until = v;
         self
     }
-    pub fn id<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.id = v.into();
+    pub fn id(mut self, v: Uint32) -> Self {
+        self.id = v;
         self
     }
-    pub fn cancel<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.cancel = v.into();
+    pub fn cancel(mut self, v: Uint32) -> Self {
+        self.cancel = v;
         self
     }
-    pub fn priority<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.priority = v.into();
+    pub fn priority(mut self, v: Uint32) -> Self {
+        self.priority = v;
         self
     }
-    pub fn message<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.message = v.into();
+    pub fn message(mut self, v: Bytes) -> Self {
+        self.message = v;
         self
     }
-    pub fn min_version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.min_version = v.into();
+    pub fn min_version(mut self, v: BytesOpt) -> Self {
+        self.min_version = v;
         self
     }
-    pub fn max_version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesOpt>,
-    {
-        self.max_version = v.into();
+    pub fn max_version(mut self, v: BytesOpt) -> Self {
+        self.max_version = v;
         self
     }
 }
@@ -20731,25 +19776,19 @@ impl<'r> molecule::prelude::Reader<'r> for AlertReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct AlertBuilder {
     pub(crate) raw: RawAlert,
     pub(crate) signatures: BytesVec,
 }
 impl AlertBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn raw<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<RawAlert>,
-    {
-        self.raw = v.into();
+    pub fn raw(mut self, v: RawAlert) -> Self {
+        self.raw = v;
         self
     }
-    pub fn signatures<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesVec>,
-    {
-        self.signatures = v.into();
+    pub fn signatures(mut self, v: BytesVec) -> Self {
+        self.signatures = v;
         self
     }
 }
@@ -21016,7 +20055,7 @@ impl<'r> molecule::prelude::Reader<'r> for IdentifyReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct IdentifyBuilder {
     pub(crate) flag: Uint64,
     pub(crate) name: Bytes,
@@ -21024,25 +20063,16 @@ pub struct IdentifyBuilder {
 }
 impl IdentifyBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn flag<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.flag = v.into();
+    pub fn flag(mut self, v: Uint64) -> Self {
+        self.flag = v;
         self
     }
-    pub fn name<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.name = v.into();
+    pub fn name(mut self, v: Bytes) -> Self {
+        self.name = v;
         self
     }
-    pub fn client_version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.client_version = v.into();
+    pub fn client_version(mut self, v: Bytes) -> Self {
+        self.client_version = v;
         self
     }
 }
diff --git a/util/gen-types/src/generated/mod.rs b/util/gen-types/src/generated/mod.rs
index 03d3f97092..fd81a946d0 100644
--- a/util/gen-types/src/generated/mod.rs
+++ b/util/gen-types/src/generated/mod.rs
@@ -3,8 +3,6 @@
 #![doc(hidden)]
 #![allow(warnings)]
 #![allow(missing_docs)]
-#![allow(clippy::all)]
-#![allow(clippy::fallible_impl_from)]
 
 #[allow(clippy::all)]
 mod blockchain;
diff --git a/util/gen-types/src/generated/protocols.rs b/util/gen-types/src/generated/protocols.rs
index 797c57b804..030d4e6b48 100644
--- a/util/gen-types/src/generated/protocols.rs
+++ b/util/gen-types/src/generated/protocols.rs
@@ -1,4 +1,4 @@
-// Generated by Molecule 0.8.0
+// Generated by Molecule 0.7.5
 
 use super::blockchain::*;
 use super::extensions::*;
@@ -140,7 +140,7 @@ impl<'r> molecule::prelude::Reader<'r> for PingPayloadReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct PingPayloadBuilder(pub(crate) PingPayloadUnion);
 impl PingPayloadBuilder {
     pub const ITEMS_COUNT: usize = 2;
@@ -298,16 +298,6 @@ impl<'r> PingPayloadUnionReader<'r> {
         }
     }
 }
-impl From<Ping> for PingPayload {
-    fn from(value: Ping) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<Pong> for PingPayload {
-    fn from(value: Pong) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
 #[derive(Clone)]
 pub struct PingMessage(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for PingMessage {
@@ -507,17 +497,14 @@ impl<'r> molecule::prelude::Reader<'r> for PingMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct PingMessageBuilder {
     pub(crate) payload: PingPayload,
 }
 impl PingMessageBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn payload<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<PingPayload>,
-    {
-        self.payload = v.into();
+    pub fn payload(mut self, v: PingPayload) -> Self {
+        self.payload = v;
         self
     }
 }
@@ -743,17 +730,14 @@ impl<'r> molecule::prelude::Reader<'r> for PingReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct PingBuilder {
     pub(crate) nonce: Uint32,
 }
 impl PingBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn nonce<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.nonce = v.into();
+    pub fn nonce(mut self, v: Uint32) -> Self {
+        self.nonce = v;
         self
     }
 }
@@ -979,17 +963,14 @@ impl<'r> molecule::prelude::Reader<'r> for PongReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct PongBuilder {
     pub(crate) nonce: Uint32,
 }
 impl PongBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn nonce<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.nonce = v.into();
+    pub fn nonce(mut self, v: Uint32) -> Self {
+        self.nonce = v;
         self
     }
 }
@@ -1241,31 +1222,27 @@ impl<'r> molecule::prelude::Reader<'r> for NodeVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct NodeVecBuilder(pub(crate) Vec<Node>);
 impl NodeVecBuilder {
     pub fn set(mut self, v: Vec<Node>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Node>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Node) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Node>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Node>
-    where
-        T: ::core::convert::Into<Node>,
-    {
+    pub fn replace(&mut self, index: usize, v: Node) -> Option<Node> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for NodeVecBuilder {
@@ -1362,16 +1339,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for NodeVecReaderIterator<'t, '
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Node> for NodeVec {
-    fn from_iter<T: IntoIterator<Item = Node>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Node>> for NodeVec {
-    fn from(v: Vec<Node>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Node2Vec(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Node2Vec {
@@ -1595,31 +1562,27 @@ impl<'r> molecule::prelude::Reader<'r> for Node2VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Node2VecBuilder(pub(crate) Vec<Node2>);
 impl Node2VecBuilder {
     pub fn set(mut self, v: Vec<Node2>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Node2>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Node2) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Node2>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Node2>
-    where
-        T: ::core::convert::Into<Node2>,
-    {
+    pub fn replace(&mut self, index: usize, v: Node2) -> Option<Node2> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for Node2VecBuilder {
@@ -1716,16 +1679,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for Node2VecReaderIterator<'t,
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Node2> for Node2Vec {
-    fn from_iter<T: IntoIterator<Item = Node2>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Node2>> for Node2Vec {
-    fn from(v: Vec<Node2>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Uint16(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Uint16 {
@@ -1856,7 +1809,6 @@ impl<'r> molecule::prelude::Reader<'r> for Uint16Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone)]
 pub struct Uint16Builder(pub(crate) [Byte; 2]);
 impl ::core::fmt::Debug for Uint16Builder {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -1872,25 +1824,16 @@ impl Uint16Builder {
     pub const TOTAL_SIZE: usize = 2;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 2;
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<[Byte; 2]>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: [Byte; 2]) -> Self {
+        self.0 = v;
         self
     }
-    pub fn nth0<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[0] = v.into();
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
         self
     }
-    pub fn nth1<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Byte>,
-    {
-        self.0[1] = v.into();
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
         self
     }
 }
@@ -1912,54 +1855,6 @@ impl molecule::prelude::Builder for Uint16Builder {
         Uint16::new_unchecked(inner.into())
     }
 }
-impl From<[Byte; 2usize]> for Uint16 {
-    fn from(value: [Byte; 2usize]) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl ::core::convert::TryFrom<&[Byte]> for Uint16 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(Self::new_builder()
-            .set(<&[Byte; 2usize]>::try_from(value)?.clone())
-            .build())
-    }
-}
-impl From<Uint16> for [Byte; 2usize] {
-    #[track_caller]
-    fn from(value: Uint16) -> Self {
-        [value.nth0(), value.nth1()]
-    }
-}
-impl From<[u8; 2usize]> for Uint16 {
-    fn from(value: [u8; 2usize]) -> Self {
-        Uint16Reader::new_unchecked(&value).to_entity()
-    }
-}
-impl ::core::convert::TryFrom<&[u8]> for Uint16 {
-    type Error = ::core::array::TryFromSliceError;
-    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
-        Ok(<[u8; 2usize]>::try_from(value)?.into())
-    }
-}
-impl From<Uint16> for [u8; 2usize] {
-    #[track_caller]
-    fn from(value: Uint16) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<Uint16Reader<'a>> for &'a [u8; 2usize] {
-    #[track_caller]
-    fn from(value: Uint16Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
-impl<'a> From<&'a Uint16Reader<'a>> for &'a [u8; 2usize] {
-    #[track_caller]
-    fn from(value: &'a Uint16Reader<'a>) -> Self {
-        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
-    }
-}
 #[derive(Clone)]
 pub struct PortOpt(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for PortOpt {
@@ -2094,14 +1989,11 @@ impl<'r> molecule::prelude::Reader<'r> for PortOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct PortOptBuilder(pub(crate) Option<Uint16>);
 impl PortOptBuilder {
-    pub fn set<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Option<Uint16>>,
-    {
-        self.0 = v.into();
+    pub fn set(mut self, v: Option<Uint16>) -> Self {
+        self.0 = v;
         self
     }
 }
@@ -2127,11 +2019,6 @@ impl molecule::prelude::Builder for PortOptBuilder {
         PortOpt::new_unchecked(inner.into())
     }
 }
-impl From<Uint16> for PortOpt {
-    fn from(value: Uint16) -> Self {
-        Self::new_builder().set(Some(value)).build()
-    }
-}
 #[derive(Clone)]
 pub struct DiscoveryPayload(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for DiscoveryPayload {
@@ -2271,7 +2158,7 @@ impl<'r> molecule::prelude::Reader<'r> for DiscoveryPayloadReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct DiscoveryPayloadBuilder(pub(crate) DiscoveryPayloadUnion);
 impl DiscoveryPayloadBuilder {
     pub const ITEMS_COUNT: usize = 2;
@@ -2429,16 +2316,6 @@ impl<'r> DiscoveryPayloadUnionReader<'r> {
         }
     }
 }
-impl From<GetNodes> for DiscoveryPayload {
-    fn from(value: GetNodes) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
-impl From<Nodes> for DiscoveryPayload {
-    fn from(value: Nodes) -> Self {
-        Self::new_builder().set(value).build()
-    }
-}
 #[derive(Clone)]
 pub struct DiscoveryMessage(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for DiscoveryMessage {
@@ -2639,17 +2516,14 @@ impl<'r> molecule::prelude::Reader<'r> for DiscoveryMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct DiscoveryMessageBuilder {
     pub(crate) payload: DiscoveryPayload,
 }
 impl DiscoveryMessageBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn payload<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<DiscoveryPayload>,
-    {
-        self.payload = v.into();
+    pub fn payload(mut self, v: DiscoveryPayload) -> Self {
+        self.payload = v;
         self
     }
 }
@@ -2910,7 +2784,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetNodesReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetNodesBuilder {
     pub(crate) version: Uint32,
     pub(crate) count: Uint32,
@@ -2918,25 +2792,16 @@ pub struct GetNodesBuilder {
 }
 impl GetNodesBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.version = v.into();
+    pub fn version(mut self, v: Uint32) -> Self {
+        self.version = v;
         self
     }
-    pub fn count<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.count = v.into();
+    pub fn count(mut self, v: Uint32) -> Self {
+        self.count = v;
         self
     }
-    pub fn listen_port<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<PortOpt>,
-    {
-        self.listen_port = v.into();
+    pub fn listen_port(mut self, v: PortOpt) -> Self {
+        self.listen_port = v;
         self
     }
 }
@@ -3223,7 +3088,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetNodes2Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct GetNodes2Builder {
     pub(crate) version: Uint32,
     pub(crate) count: Uint32,
@@ -3232,32 +3097,20 @@ pub struct GetNodes2Builder {
 }
 impl GetNodes2Builder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn version<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.version = v.into();
+    pub fn version(mut self, v: Uint32) -> Self {
+        self.version = v;
         self
     }
-    pub fn count<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint32>,
-    {
-        self.count = v.into();
+    pub fn count(mut self, v: Uint32) -> Self {
+        self.count = v;
         self
     }
-    pub fn listen_port<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<PortOpt>,
-    {
-        self.listen_port = v.into();
+    pub fn listen_port(mut self, v: PortOpt) -> Self {
+        self.listen_port = v;
         self
     }
-    pub fn required_flags<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.required_flags = v.into();
+    pub fn required_flags(mut self, v: Uint64) -> Self {
+        self.required_flags = v;
         self
     }
 }
@@ -3513,25 +3366,19 @@ impl<'r> molecule::prelude::Reader<'r> for NodesReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct NodesBuilder {
     pub(crate) announce: Bool,
     pub(crate) items: NodeVec,
 }
 impl NodesBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn announce<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bool>,
-    {
-        self.announce = v.into();
+    pub fn announce(mut self, v: Bool) -> Self {
+        self.announce = v;
         self
     }
-    pub fn items<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<NodeVec>,
-    {
-        self.items = v.into();
+    pub fn items(mut self, v: NodeVec) -> Self {
+        self.items = v;
         self
     }
 }
@@ -3779,25 +3626,19 @@ impl<'r> molecule::prelude::Reader<'r> for Nodes2Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Nodes2Builder {
     pub(crate) announce: Bool,
     pub(crate) items: Node2Vec,
 }
 impl Nodes2Builder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn announce<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bool>,
-    {
-        self.announce = v.into();
+    pub fn announce(mut self, v: Bool) -> Self {
+        self.announce = v;
         self
     }
-    pub fn items<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Node2Vec>,
-    {
-        self.items = v.into();
+    pub fn items(mut self, v: Node2Vec) -> Self {
+        self.items = v;
         self
     }
 }
@@ -4028,17 +3869,14 @@ impl<'r> molecule::prelude::Reader<'r> for NodeReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct NodeBuilder {
     pub(crate) addresses: BytesVec,
 }
 impl NodeBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn addresses<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesVec>,
-    {
-        self.addresses = v.into();
+    pub fn addresses(mut self, v: BytesVec) -> Self {
+        self.addresses = v;
         self
     }
 }
@@ -4283,25 +4121,19 @@ impl<'r> molecule::prelude::Reader<'r> for Node2Reader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct Node2Builder {
     pub(crate) addresses: BytesVec,
     pub(crate) flags: Uint64,
 }
 impl Node2Builder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn addresses<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<BytesVec>,
-    {
-        self.addresses = v.into();
+    pub fn addresses(mut self, v: BytesVec) -> Self {
+        self.addresses = v;
         self
     }
-    pub fn flags<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Uint64>,
-    {
-        self.flags = v.into();
+    pub fn flags(mut self, v: Uint64) -> Self {
+        self.flags = v;
         self
     }
 }
@@ -4558,31 +4390,27 @@ impl<'r> molecule::prelude::Reader<'r> for AddressVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct AddressVecBuilder(pub(crate) Vec<Address>);
 impl AddressVecBuilder {
     pub fn set(mut self, v: Vec<Address>) -> Self {
         self.0 = v;
         self
     }
-    pub fn push<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Address>,
-    {
-        self.0.push(v.into());
+    pub fn push(mut self, v: Address) -> Self {
+        self.0.push(v);
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Address>>(mut self, iter: T) -> Self {
-        self.0.extend(iter);
+        for elem in iter {
+            self.0.push(elem);
+        }
         self
     }
-    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Address>
-    where
-        T: ::core::convert::Into<Address>,
-    {
+    pub fn replace(&mut self, index: usize, v: Address) -> Option<Address> {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v.into()))
+            .map(|item| ::core::mem::replace(item, v))
     }
 }
 impl molecule::prelude::Builder for AddressVecBuilder {
@@ -4679,16 +4507,6 @@ impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for AddressVecReaderIterator<'t
         self.2 - self.1
     }
 }
-impl ::core::iter::FromIterator<Address> for AddressVec {
-    fn from_iter<T: IntoIterator<Item = Address>>(iter: T) -> Self {
-        Self::new_builder().extend(iter).build()
-    }
-}
-impl From<Vec<Address>> for AddressVec {
-    fn from(v: Vec<Address>) -> Self {
-        Self::new_builder().set(v).build()
-    }
-}
 #[derive(Clone)]
 pub struct Address(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for Address {
@@ -4886,17 +4704,14 @@ impl<'r> molecule::prelude::Reader<'r> for AddressReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct AddressBuilder {
     pub(crate) bytes: Bytes,
 }
 impl AddressBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn bytes<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.bytes = v.into();
+    pub fn bytes(mut self, v: Bytes) -> Self {
+        self.bytes = v;
         self
     }
 }
@@ -5158,7 +4973,7 @@ impl<'r> molecule::prelude::Reader<'r> for IdentifyMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct IdentifyMessageBuilder {
     pub(crate) listen_addrs: AddressVec,
     pub(crate) observed_addr: Address,
@@ -5166,25 +4981,16 @@ pub struct IdentifyMessageBuilder {
 }
 impl IdentifyMessageBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn listen_addrs<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<AddressVec>,
-    {
-        self.listen_addrs = v.into();
+    pub fn listen_addrs(mut self, v: AddressVec) -> Self {
+        self.listen_addrs = v;
         self
     }
-    pub fn observed_addr<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Address>,
-    {
-        self.observed_addr = v.into();
+    pub fn observed_addr(mut self, v: Address) -> Self {
+        self.observed_addr = v;
         self
     }
-    pub fn identify<T>(mut self, v: T) -> Self
-    where
-        T: ::core::convert::Into<Bytes>,
-    {
-        self.identify = v.into();
+    pub fn identify(mut self, v: Bytes) -> Self {
+        self.identify = v;
         self
     }
 }
diff --git a/util/indexer-sync/src/lib.rs b/util/indexer-sync/src/lib.rs
index 4c8325be7e..135d516e17 100644
--- a/util/indexer-sync/src/lib.rs
+++ b/util/indexer-sync/src/lib.rs
@@ -26,6 +26,7 @@ use ckb_store::ChainStore;
 use ckb_types::{
     core::{self, BlockNumber, BlockView},
     packed::Byte32,
+    prelude::*,
     H256,
 };
 use rocksdb::prelude::*;
@@ -111,7 +112,7 @@ impl IndexerSyncService {
                 .tip()
                 .expect("indexer_service tip should be OK");
             if let Some((indexer_tip, _)) = indexer_tip {
-                if let Some(init_tip) = self.secondary_db.get_block_header(&init_tip_hash.into()) {
+                if let Some(init_tip) = self.secondary_db.get_block_header(&init_tip_hash.pack()) {
                     if indexer_tip >= init_tip.number() {
                         return;
                     }
@@ -126,7 +127,7 @@ impl IndexerSyncService {
                 if let Err(e) = self.secondary_db.try_catch_up_with_primary() {
                     error!("secondary_db try_catch_up_with_primary error {}", e);
                 }
-                if let Some(header) = self.secondary_db.get_block_header(&init_tip_hash.into()) {
+                if let Some(header) = self.secondary_db.get_block_header(&init_tip_hash.pack()) {
                     let init_tip_number = header.number();
                     indexer_service.set_init_tip(init_tip_number, init_tip_hash);
                     break;
diff --git a/util/indexer/src/indexer.rs b/util/indexer/src/indexer.rs
index cbbbc53859..33f0813e86 100644
--- a/util/indexer/src/indexer.rs
+++ b/util/indexer/src/indexer.rs
@@ -354,10 +354,10 @@ where
                                     block_number,
                                     i as u32,
                                     &tx.outputs()
-                                        .get(out_point.index().into())
+                                        .get(out_point.index().unpack())
                                         .expect("index should match"),
                                     &tx.outputs_data()
-                                        .get(out_point.index().into())
+                                        .get(out_point.index().unpack())
                                         .expect("index should match"),
                                 )
                                 .into()
@@ -380,7 +380,7 @@ where
                                 &output.lock(),
                                 generated_by_block_number,
                                 generated_by_tx_index,
-                                out_point.index().into(),
+                                out_point.index().unpack(),
                             )
                             .into_vec(),
                         )?;
@@ -400,7 +400,7 @@ where
                                     &script,
                                     generated_by_block_number,
                                     generated_by_tx_index,
-                                    out_point.index().into(),
+                                    out_point.index().unpack(),
                                 )
                                 .into_vec(),
                             )?;
@@ -629,7 +629,7 @@ where
                                     &output.lock(),
                                     generated_by_block_number,
                                     generated_by_tx_index,
-                                    out_point.index().into(),
+                                    out_point.index().unpack(),
                                 ),
                                 Value::TxHash(&out_point.tx_hash()),
                             )?;
@@ -649,7 +649,7 @@ where
                                         &script,
                                         generated_by_block_number,
                                         generated_by_tx_index,
-                                        out_point.index().into(),
+                                        out_point.index().unpack(),
                                     ),
                                     Value::TxHash(&out_point.tx_hash()),
                                 )?;
@@ -702,7 +702,7 @@ where
         let mut batch = self.store.batch().expect("create batch should be OK");
         batch
             .put_kv(
-                Key::Header(init_tip_number, &init_tip_hash.into(), true),
+                Key::Header(init_tip_number, &init_tip_hash.pack(), true),
                 vec![],
             )
             .expect("insert init tip header should be OK");
@@ -938,7 +938,7 @@ mod tests {
             capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
             ScriptHashType, TransactionBuilder,
         },
-        packed::{self, CellInput, CellOutputBuilder, OutPoint, ScriptBuilder},
+        packed::{CellInput, CellOutputBuilder, OutPoint, ScriptBuilder},
         H256,
     };
 
@@ -955,27 +955,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("append_and_rollback_to_empty");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -983,40 +983,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1)
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2)
-                    .type_(Some(type_script2))
+                    .type_(Some(type_script2).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1038,27 +1038,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("append_two_blocks_and_rollback_one");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1066,40 +1066,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1108,35 +1108,35 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2)
-                    .type_(Some(type_script2))
+                    .type_(Some(type_script2).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -1145,13 +1145,12 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1)
+                    .number(1.pack())
                     .parent_hash(block0.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        block0.number() + 1,
-                        block0.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
+                            .pack(),
+                    )
                     .build(),
             )
             .build();
@@ -1200,27 +1199,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("consume_output_in_same_block");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1228,40 +1227,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0.clone())
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1270,47 +1269,47 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx12 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx11.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2))
+                    .type_(Some(type_script2).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -1320,13 +1319,12 @@ mod tests {
             .transaction(tx12)
             .header(
                 HeaderBuilder::default()
-                    .number(1)
+                    .number(1.pack())
                     .parent_hash(block0.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        block0.number() + 1,
-                        block0.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
+                            .pack(),
+                    )
                     .build(),
             )
             .build();
@@ -1373,27 +1371,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1401,40 +1399,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1447,35 +1445,35 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()))
+                        .type_(Some(type_script1.clone()).pack())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_tx1 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000))
+                        .capacity(capacity_bytes!(2000).pack())
                         .lock(lock_script2.clone())
-                        .type_(Some(type_script2.clone()))
+                        .type_(Some(type_script2.clone()).pack())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_block = BlockBuilder::default()
@@ -1484,13 +1482,16 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number(pre_block.number() + 1)
+                        .number((pre_block.number() + 1).pack())
                         .parent_hash(pre_block.hash())
-                        .epoch(EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        ))
+                        .epoch(
+                            EpochNumberWithFraction::new(
+                                pre_block.number() + 1,
+                                pre_block.number(),
+                                1000,
+                            )
+                            .pack(),
+                        )
                         .build(),
                 )
                 .build();
@@ -1525,9 +1526,9 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1535,16 +1536,16 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1557,24 +1558,27 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_block = BlockBuilder::default()
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number(pre_block.number() + 1)
+                        .number((pre_block.number() + 1).pack())
                         .parent_hash(pre_block.hash())
-                        .epoch(EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        ))
+                        .epoch(
+                            EpochNumberWithFraction::new(
+                                pre_block.number() + 1,
+                                pre_block.number(),
+                                1000,
+                            )
+                            .pack(),
+                        )
                         .build(),
                 )
                 .build();
@@ -1594,27 +1598,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("append_and_rollback_with_cellbase");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1622,40 +1626,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1)
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2)
-                    .type_(Some(type_script2))
+                    .type_(Some(type_script2).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1678,14 +1682,14 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune_should_not_delete_live_cells");
 
         let all_zero_lock_script = ScriptBuilder::default()
-            .code_hash(H256([0; 32]))
-            .hash_type(ScriptHashType::Data)
+            .code_hash(H256([0; 32]).pack())
+            .hash_type(ScriptHashType::Data.into())
             .build();
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1693,16 +1697,16 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(all_zero_lock_script.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1724,24 +1728,27 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_block = BlockBuilder::default()
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number(pre_block.number() + 1)
+                        .number((pre_block.number() + 1).pack())
                         .parent_hash(pre_block.hash())
-                        .epoch(EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        ))
+                        .epoch(
+                            EpochNumberWithFraction::new(
+                                pre_block.number() + 1,
+                                pre_block.number(),
+                                1000,
+                            )
+                            .pack(),
+                        )
                         .build(),
                 )
                 .build();
@@ -1771,8 +1778,8 @@ mod tests {
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number(i)
-                        .epoch(EpochNumberWithFraction::new(i + 1, i, 1000))
+                        .number(i.pack())
+                        .epoch(EpochNumberWithFraction::new(i + 1, i, 1000).pack())
                         .build(),
                 )
                 .build();
@@ -1797,15 +1804,15 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1813,28 +1820,28 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0.clone())
             .transaction(tx00.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1843,23 +1850,23 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -1867,13 +1874,12 @@ mod tests {
             .transaction(tx10)
             .header(
                 HeaderBuilder::default()
-                    .number(1)
+                    .number(1.pack())
                     .parent_hash(block0.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        block0.number() + 1,
-                        block0.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
+                            .pack(),
+                    )
                     .build(),
             )
             .build();
@@ -1952,27 +1958,27 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1980,40 +1986,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
         indexer.append(&block0).unwrap();
         let (tip_number, tip_hash) = indexer.tip().unwrap().unwrap();
@@ -2025,35 +2031,35 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2)
-                    .type_(Some(type_script2))
+                    .type_(Some(type_script2).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -2062,13 +2068,12 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1)
+                    .number(1.pack())
                     .parent_hash(block0.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        block0.number() + 1,
-                        block0.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
+                            .pack(),
+                    )
                     .build(),
             )
             .build();
@@ -2121,27 +2126,27 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -2149,40 +2154,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
         indexer.append(&block0).unwrap();
         let (tip_number, tip_hash) = indexer.tip().unwrap().unwrap();
@@ -2208,35 +2213,35 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2)
-                    .type_(Some(type_script2))
+                    .type_(Some(type_script2).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -2245,13 +2250,12 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1)
+                    .number(1.pack())
                     .parent_hash(block0.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        block0.number() + 1,
-                        block0.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
+                            .pack(),
+                    )
                     .build(),
             )
             .build();
diff --git a/util/indexer/src/service.rs b/util/indexer/src/service.rs
index ab594b0c62..849bb434c2 100644
--- a/util/indexer/src/service.rs
+++ b/util/indexer/src/service.rs
@@ -141,7 +141,7 @@ impl IndexerHandle {
         Ok(iter.next().map(|(key, _)| IndexerTip {
             block_hash: packed::Byte32::from_slice(&key[9..41])
                 .expect("stored block key")
-                .into(),
+                .unpack(),
             block_number: core::BlockNumber::from_be_bytes(
                 key[1..9].try_into().expect("stored block key"),
             )
@@ -301,7 +301,7 @@ impl IndexerHandle {
                 }
 
                 if let Some([r0, r1]) = filter_options.output_capacity_range {
-                    let capacity: core::Capacity = output.capacity().into();
+                    let capacity: core::Capacity = output.capacity().unpack();
                     if capacity < r0 || capacity >= r1 {
                         return None;
                     }
@@ -429,7 +429,7 @@ impl IndexerHandle {
                 }
                 let tx_hash: H256 = packed::Byte32::from_slice(&value)
                     .expect("stored tx hash")
-                    .into();
+                    .unpack();
                 if tx_with_cells.len() == limit
                     && tx_with_cells.last_mut().unwrap().tx_hash != tx_hash
                 {
@@ -613,7 +613,7 @@ impl IndexerHandle {
 
                     last_key = key.to_vec();
                     Some(IndexerTx::Ungrouped(IndexerTxWithCell {
-                        tx_hash: tx_hash.into(),
+                        tx_hash: tx_hash.unpack(),
                         block_number: block_number.into(),
                         tx_index: tx_index.into(),
                         io_index: io_index.into(),
@@ -763,7 +763,7 @@ impl IndexerHandle {
                 }
 
                 if let Some([r0, r1]) = filter_options.output_capacity_range {
-                    let capacity: core::Capacity = output.capacity().into();
+                    let capacity: core::Capacity = output.capacity().unpack();
                     if capacity < r0 || capacity >= r1 {
                         return None;
                     }
@@ -775,7 +775,7 @@ impl IndexerHandle {
                     }
                 }
 
-                Some(Into::<core::Capacity>::into(&output.capacity()).as_u64())
+                Some(Unpack::<core::Capacity>::unpack(&output.capacity()).as_u64())
             })
             .sum();
 
@@ -785,7 +785,7 @@ impl IndexerHandle {
             capacity: capacity.into(),
             block_hash: packed::Byte32::from_slice(&key[9..41])
                 .expect("stored block key")
-                .into(),
+                .unpack(),
             block_number: core::BlockNumber::from_be_bytes(
                 key[1..9].try_into().expect("stored block key"),
             )
@@ -954,27 +954,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script2".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"type_script2".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"type_script2".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -982,40 +982,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1028,35 +1028,35 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Bytes::from(i.to_string()))
+                .output_data(Bytes::from(i.to_string()).pack())
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()))
+                        .type_(Some(type_script1.clone()).pack())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_tx1 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000))
+                        .capacity(capacity_bytes!(2000).pack())
                         .lock(lock_script2.clone())
-                        .type_(Some(type_script2.clone()))
+                        .type_(Some(type_script2.clone()).pack())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_block = BlockBuilder::default()
@@ -1065,13 +1065,16 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number(pre_block.number() + 1)
+                        .number((pre_block.number() + 1).pack())
                         .parent_hash(pre_block.hash())
-                        .epoch(EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        ))
+                        .epoch(
+                            EpochNumberWithFraction::new(
+                                pre_block.number() + 1,
+                                pre_block.number(),
+                                1000,
+                            )
+                            .pack(),
+                        )
                         .build(),
                 )
                 .build();
@@ -1081,7 +1084,7 @@ mod tests {
 
         // test get_tip rpc
         let tip = rpc.get_indexer_tip().unwrap().unwrap();
-        assert_eq!(Into::<H256>::into(&pre_block.hash()), tip.block_hash);
+        assert_eq!(Unpack::<H256>::unpack(&pre_block.hash()), tip.block_hash);
         assert_eq!(pre_block.number(), tip.block_number.value());
 
         // test get_cells rpc
@@ -1473,12 +1476,12 @@ mod tests {
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
         pool.write().unwrap().new_transaction(&pool_tx);
 
@@ -1539,27 +1542,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script11 = ScriptBuilder::default()
             .code_hash(lock_script1.code_hash())
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script11".to_vec()))
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script11".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script11 = ScriptBuilder::default()
             .code_hash(type_script1.code_hash())
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script11".to_vec()))
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script11".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1567,40 +1570,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11.clone()))
+                    .type_(Some(type_script11.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1613,35 +1616,35 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Bytes::from(i.to_string()))
+                .output_data(Bytes::from(i.to_string()).pack())
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000))
+                        .capacity(capacity_bytes!(1000).pack())
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()))
+                        .type_(Some(type_script1.clone()).pack())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_tx1 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000))
+                        .capacity(capacity_bytes!(2000).pack())
                         .lock(lock_script11.clone())
-                        .type_(Some(type_script11.clone()))
+                        .type_(Some(type_script11.clone()).pack())
                         .build(),
                 )
-                .output_data(packed::Bytes::default())
+                .output_data(Default::default())
                 .build();
 
             pre_block = BlockBuilder::default()
@@ -1650,13 +1653,16 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number(pre_block.number() + 1)
+                        .number((pre_block.number() + 1).pack())
                         .parent_hash(pre_block.hash())
-                        .epoch(EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        ))
+                        .epoch(
+                            EpochNumberWithFraction::new(
+                                pre_block.number() + 1,
+                                pre_block.number(),
+                                1000,
+                            )
+                            .pack(),
+                        )
                         .build(),
                 )
                 .build();
@@ -1781,9 +1787,9 @@ mod tests {
         };
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
         let data = [0u8; 7];
         let res = rpc.get_cells(
@@ -1815,27 +1821,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script1".to_vec()).pack())
             .build();
 
         let lock_script11 = ScriptBuilder::default()
             .code_hash(lock_script1.code_hash())
-            .hash_type(ScriptHashType::Type)
-            .args(Bytes::from(b"lock_script11".to_vec()))
+            .hash_type(ScriptHashType::Type.into())
+            .args(Bytes::from(b"lock_script11".to_vec()).pack())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()))
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script1".to_vec()))
+            .code_hash(H256(rand::random()).pack())
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script1".to_vec()).pack())
             .build();
 
         let type_script11 = ScriptBuilder::default()
             .code_hash(type_script1.code_hash())
-            .hash_type(ScriptHashType::Data)
-            .args(Bytes::from(b"type_script11".to_vec()))
+            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(b"type_script11".to_vec()).pack())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1843,22 +1849,22 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1)
-                    .type_(Some(type_script1))
+                    .type_(Some(type_script1).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         let mut data = [0u8; 7];
@@ -1866,19 +1872,19 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11))
+                    .type_(Some(type_script11).pack())
                     .build(),
             )
-            .output_data(data.to_vec())
+            .output_data(data.to_vec().pack())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0).build())
+            .header(HeaderBuilder::default().number(0.pack()).build())
             .build();
 
         indexer.append(&block0).unwrap();
diff --git a/util/jsonrpc-types/src/alert.rs b/util/jsonrpc-types/src/alert.rs
index 5331da39ba..bbb459830c 100644
--- a/util/jsonrpc-types/src/alert.rs
+++ b/util/jsonrpc-types/src/alert.rs
@@ -86,22 +86,17 @@ impl From<Alert> for packed::Alert {
             signatures,
         } = json;
         let raw = packed::RawAlert::new_builder()
-            .id(id)
-            .cancel(cancel)
-            .min_version(min_version)
-            .max_version(max_version)
-            .priority(priority)
-            .notice_until(notice_until)
-            .message(message)
+            .id(id.pack())
+            .cancel(cancel.pack())
+            .min_version(min_version.pack())
+            .max_version(max_version.pack())
+            .priority(priority.pack())
+            .notice_until(notice_until.pack())
+            .message(message.pack())
             .build();
         packed::Alert::new_builder()
             .raw(raw)
-            .signatures(
-                signatures
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::Bytes>>(),
-            )
+            .signatures(signatures.into_iter().map(Into::into).pack())
             .build()
     }
 }
@@ -110,8 +105,8 @@ impl From<packed::Alert> for Alert {
     fn from(input: packed::Alert) -> Self {
         let raw = input.raw();
         Alert {
-            id: raw.id().into(),
-            cancel: raw.cancel().into(),
+            id: raw.id().unpack(),
+            cancel: raw.cancel().unpack(),
             min_version: raw
                 .as_reader()
                 .min_version()
@@ -122,8 +117,8 @@ impl From<packed::Alert> for Alert {
                 .max_version()
                 .to_opt()
                 .map(|b| unsafe { b.as_utf8_unchecked() }.to_owned()),
-            priority: raw.priority().into(),
-            notice_until: raw.notice_until().into(),
+            priority: raw.priority().unpack(),
+            notice_until: raw.notice_until().unpack(),
             message: unsafe { raw.as_reader().message().as_utf8_unchecked() }.to_owned(),
             signatures: input.signatures().into_iter().map(Into::into).collect(),
         }
@@ -134,9 +129,9 @@ impl From<packed::Alert> for AlertMessage {
     fn from(input: packed::Alert) -> Self {
         let raw = input.raw();
         AlertMessage {
-            id: raw.id().into(),
-            priority: raw.priority().into(),
-            notice_until: raw.notice_until().into(),
+            id: raw.id().unpack(),
+            priority: raw.priority().unpack(),
+            notice_until: raw.notice_until().unpack(),
             message: unsafe { raw.as_reader().message().as_utf8_unchecked() }.to_owned(),
         }
     }
diff --git a/util/jsonrpc-types/src/block_template.rs b/util/jsonrpc-types/src/block_template.rs
index d2ab354f8a..8e49f9bf72 100644
--- a/util/jsonrpc-types/src/block_template.rs
+++ b/util/jsonrpc-types/src/block_template.rs
@@ -115,17 +115,17 @@ impl From<BlockTemplate> for packed::Block {
             ..
         } = block_template;
         let raw = packed::RawHeader::new_builder()
-            .version(version)
-            .compact_target(compact_target)
-            .parent_hash(parent_hash)
-            .timestamp(current_time)
-            .number(number)
-            .epoch(epoch)
-            .dao(dao)
+            .version(version.pack())
+            .compact_target(compact_target.pack())
+            .parent_hash(parent_hash.pack())
+            .timestamp(current_time.pack())
+            .number(number.pack())
+            .epoch(epoch.pack())
+            .dao(dao.into())
             .build();
         let header = packed::Header::new_builder().raw(raw).build();
         let txs = packed::TransactionVec::new_builder()
-            .push(cellbase)
+            .push(cellbase.into())
             .extend(transactions.into_iter().map(|tx| tx.into()))
             .build();
         if let Some(extension) = extension {
@@ -136,14 +136,16 @@ impl From<BlockTemplate> for packed::Block {
                     uncles
                         .into_iter()
                         .map(|u| u.into())
-                        .collect::<Vec<packed::UncleBlock>>(),
+                        .collect::<Vec<packed::UncleBlock>>()
+                        .pack(),
                 )
                 .transactions(txs)
                 .proposals(
                     proposals
                         .into_iter()
                         .map(|p| p.into())
-                        .collect::<Vec<packed::ProposalShortId>>(),
+                        .collect::<Vec<packed::ProposalShortId>>()
+                        .pack(),
                 )
                 .extension(extension)
                 .build()
@@ -155,14 +157,16 @@ impl From<BlockTemplate> for packed::Block {
                     uncles
                         .into_iter()
                         .map(|u| u.into())
-                        .collect::<Vec<packed::UncleBlock>>(),
+                        .collect::<Vec<packed::UncleBlock>>()
+                        .pack(),
                 )
                 .transactions(txs)
                 .proposals(
                     proposals
                         .into_iter()
                         .map(|p| p.into())
-                        .collect::<Vec<packed::ProposalShortId>>(),
+                        .collect::<Vec<packed::ProposalShortId>>()
+                        .pack(),
                 )
                 .build()
         }
@@ -193,13 +197,8 @@ impl From<UncleTemplate> for packed::UncleBlock {
             proposals, header, ..
         } = template;
         packed::UncleBlock::new_builder()
-            .header(header)
-            .proposals(
-                proposals
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::ProposalShortId>>(),
-            )
+            .header(header.into())
+            .proposals(proposals.into_iter().map(Into::into).pack())
             .build()
     }
 }
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index 409ff1ad21..e5812d1d9e 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -105,9 +105,9 @@ impl From<Script> for packed::Script {
         } = json;
         let hash_type: core::ScriptHashType = hash_type.into();
         packed::Script::new_builder()
-            .args(args.into_bytes())
-            .code_hash(code_hash)
-            .hash_type(hash_type)
+            .args(args.into_bytes().pack())
+            .code_hash(code_hash.pack())
+            .hash_type(hash_type.into())
             .build()
     }
 }
@@ -115,8 +115,8 @@ impl From<Script> for packed::Script {
 impl From<packed::Script> for Script {
     fn from(input: packed::Script) -> Script {
         Script {
-            code_hash: input.code_hash().into(),
-            args: JsonBytes::from_vec(input.args().into()),
+            code_hash: input.code_hash().unpack(),
+            args: JsonBytes::from_vec(input.args().unpack()),
             hash_type: core::ScriptHashType::try_from(input.hash_type())
                 .expect("checked data")
                 .into(),
@@ -161,7 +161,7 @@ pub struct CellOutput {
 impl From<packed::CellOutput> for CellOutput {
     fn from(input: packed::CellOutput) -> CellOutput {
         CellOutput {
-            capacity: input.capacity().into(),
+            capacity: input.capacity().unpack(),
             lock: input.lock().into(),
             type_: input.type_().to_opt().map(Into::into),
         }
@@ -182,8 +182,8 @@ impl From<CellOutput> for packed::CellOutput {
         }
         .build();
         packed::CellOutput::new_builder()
-            .capacity(capacity)
-            .lock(lock)
+            .capacity(capacity.pack())
+            .lock(lock.into())
             .type_(type_)
             .build()
     }
@@ -212,9 +212,9 @@ pub struct OutPoint {
 
 impl From<packed::OutPoint> for OutPoint {
     fn from(input: packed::OutPoint) -> OutPoint {
-        let index: u32 = input.index().into();
+        let index: u32 = input.index().unpack();
         OutPoint {
-            tx_hash: input.tx_hash().into(),
+            tx_hash: input.tx_hash().unpack(),
             index: index.into(),
         }
     }
@@ -225,8 +225,8 @@ impl From<OutPoint> for packed::OutPoint {
         let OutPoint { tx_hash, index } = json;
         let index = index.value();
         packed::OutPoint::new_builder()
-            .tx_hash(tx_hash)
-            .index(index)
+            .tx_hash(tx_hash.pack())
+            .index(index.pack())
             .build()
     }
 }
@@ -261,7 +261,7 @@ impl From<packed::CellInput> for CellInput {
     fn from(input: packed::CellInput) -> CellInput {
         CellInput {
             previous_output: input.previous_output().into(),
-            since: input.since().into(),
+            since: input.since().unpack(),
         }
     }
 }
@@ -273,8 +273,8 @@ impl From<CellInput> for packed::CellInput {
             since,
         } = json;
         packed::CellInput::new_builder()
-            .previous_output(previous_output)
-            .since(since)
+            .previous_output(previous_output.into())
+            .since(since.pack())
             .build()
     }
 }
@@ -359,8 +359,8 @@ impl From<CellDep> for packed::CellDep {
         } = json;
         let dep_type: core::DepType = dep_type.into();
         packed::CellDep::new_builder()
-            .out_point(out_point)
-            .dep_type(dep_type)
+            .out_point(out_point.into())
+            .dep_type(dep_type.into())
             .build()
     }
 }
@@ -470,12 +470,12 @@ impl From<packed::Transaction> for Transaction {
     fn from(input: packed::Transaction) -> Self {
         let raw = input.raw();
         Self {
-            version: raw.version().into(),
+            version: raw.version().unpack(),
             cell_deps: raw.cell_deps().into_iter().map(Into::into).collect(),
             header_deps: raw
                 .header_deps()
                 .into_iter()
-                .map(|d| Into::<H256>::into(&d))
+                .map(|d| Unpack::<H256>::unpack(&d))
                 .collect(),
             inputs: raw.inputs().into_iter().map(Into::into).collect(),
             outputs: raw.outputs().into_iter().map(Into::into).collect(),
@@ -489,7 +489,7 @@ impl From<core::TransactionView> for TransactionView {
     fn from(input: core::TransactionView) -> Self {
         Self {
             inner: input.data().into(),
-            hash: input.hash().into(),
+            hash: input.hash().unpack(),
         }
     }
 }
@@ -506,46 +506,16 @@ impl From<Transaction> for packed::Transaction {
             outputs_data,
         } = json;
         let raw = packed::RawTransaction::new_builder()
-            .version(version)
-            .cell_deps(
-                cell_deps
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::CellDep>>(),
-            )
-            .header_deps(
-                header_deps
-                    .iter()
-                    .map(Pack::pack)
-                    .collect::<Vec<packed::Byte32>>(),
-            )
-            .inputs(
-                inputs
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::CellInput>>(),
-            )
-            .outputs(
-                outputs
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::CellOutput>>(),
-            )
-            .outputs_data(
-                outputs_data
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::Bytes>>(),
-            )
+            .version(version.pack())
+            .cell_deps(cell_deps.into_iter().map(Into::into).pack())
+            .header_deps(header_deps.iter().map(Pack::pack).pack())
+            .inputs(inputs.into_iter().map(Into::into).pack())
+            .outputs(outputs.into_iter().map(Into::into).pack())
+            .outputs_data(outputs_data.into_iter().map(Into::into).pack())
             .build();
         packed::Transaction::new_builder()
             .raw(raw)
-            .witnesses(
-                witnesses
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::Bytes>>(),
-            )
+            .witnesses(witnesses.into_iter().map(Into::into).pack())
             .build()
     }
 }
@@ -814,17 +784,17 @@ impl From<packed::Header> for Header {
     fn from(input: packed::Header) -> Self {
         let raw = input.raw();
         Self {
-            version: raw.version().into(),
-            parent_hash: raw.parent_hash().into(),
-            timestamp: raw.timestamp().into(),
-            number: raw.number().into(),
-            epoch: raw.epoch().into(),
-            transactions_root: raw.transactions_root().into(),
-            proposals_hash: raw.proposals_hash().into(),
-            compact_target: raw.compact_target().into(),
-            extra_hash: raw.extra_hash().into(),
+            version: raw.version().unpack(),
+            parent_hash: raw.parent_hash().unpack(),
+            timestamp: raw.timestamp().unpack(),
+            number: raw.number().unpack(),
+            epoch: raw.epoch().unpack(),
+            transactions_root: raw.transactions_root().unpack(),
+            proposals_hash: raw.proposals_hash().unpack(),
+            compact_target: raw.compact_target().unpack(),
+            extra_hash: raw.extra_hash().unpack(),
             dao: raw.dao().into(),
-            nonce: input.nonce().into(),
+            nonce: input.nonce().unpack(),
         }
     }
 }
@@ -833,7 +803,7 @@ impl From<core::HeaderView> for HeaderView {
     fn from(input: core::HeaderView) -> Self {
         Self {
             inner: input.data().into(),
-            hash: input.hash().into(),
+            hash: input.hash().unpack(),
         }
     }
 }
@@ -861,18 +831,21 @@ impl From<Header> for packed::Header {
             nonce,
         } = json;
         let raw = packed::RawHeader::new_builder()
-            .version(version)
-            .parent_hash(parent_hash)
-            .timestamp(timestamp)
-            .number(number)
-            .epoch(epoch)
-            .transactions_root(transactions_root)
-            .proposals_hash(proposals_hash)
-            .compact_target(compact_target)
-            .extra_hash(extra_hash)
-            .dao(dao)
+            .version(version.pack())
+            .parent_hash(parent_hash.pack())
+            .timestamp(timestamp.pack())
+            .number(number.pack())
+            .epoch(epoch.pack())
+            .transactions_root(transactions_root.pack())
+            .proposals_hash(proposals_hash.pack())
+            .compact_target(compact_target.pack())
+            .extra_hash(extra_hash.pack())
+            .dao(dao.into())
             .build();
-        packed::Header::new_builder().raw(raw).nonce(nonce).build()
+        packed::Header::new_builder()
+            .raw(raw)
+            .nonce(nonce.pack())
+            .build()
     }
 }
 
@@ -930,7 +903,7 @@ impl From<core::UncleBlockView> for UncleBlockView {
     fn from(input: core::UncleBlockView) -> Self {
         let header = HeaderView {
             inner: input.data().header().into(),
-            hash: input.hash().into(),
+            hash: input.hash().unpack(),
         };
         Self {
             header,
@@ -948,13 +921,8 @@ impl From<UncleBlock> for packed::UncleBlock {
     fn from(json: UncleBlock) -> Self {
         let UncleBlock { header, proposals } = json;
         packed::UncleBlock::new_builder()
-            .header(header)
-            .proposals(
-                proposals
-                    .into_iter()
-                    .map(Into::into)
-                    .collect::<Vec<packed::ProposalShortId>>(),
-            )
+            .header(header.into())
+            .proposals(proposals.into_iter().map(Into::into).pack())
             .build()
     }
 }
@@ -1061,7 +1029,7 @@ impl From<core::BlockView> for BlockView {
         let block = input.data();
         let header = HeaderView {
             inner: block.header().into(),
-            hash: input.hash().into(),
+            hash: input.hash().unpack(),
         };
         let uncles = block
             .uncles()
@@ -1070,7 +1038,7 @@ impl From<core::BlockView> for BlockView {
             .map(|(uncle, hash)| {
                 let header = HeaderView {
                     inner: uncle.header().into(),
-                    hash: hash.into(),
+                    hash: hash.unpack(),
                 };
                 UncleBlockView {
                     header,
@@ -1084,7 +1052,7 @@ impl From<core::BlockView> for BlockView {
             .zip(input.tx_hashes().iter())
             .map(|(tx, hash)| TransactionView {
                 inner: tx.into(),
-                hash: hash.into(),
+                hash: hash.unpack(),
             })
             .collect();
         Self {
@@ -1109,49 +1077,19 @@ impl From<Block> for packed::Block {
         if let Some(extension) = extension {
             let extension: packed::Bytes = extension.into();
             packed::BlockV1::new_builder()
-                .header(header)
-                .uncles(
-                    uncles
-                        .into_iter()
-                        .map(Into::into)
-                        .collect::<Vec<packed::UncleBlock>>(),
-                )
-                .transactions(
-                    transactions
-                        .into_iter()
-                        .map(Into::into)
-                        .collect::<Vec<packed::Transaction>>(),
-                )
-                .proposals(
-                    proposals
-                        .into_iter()
-                        .map(Into::into)
-                        .collect::<Vec<packed::ProposalShortId>>(),
-                )
+                .header(header.into())
+                .uncles(uncles.into_iter().map(Into::into).pack())
+                .transactions(transactions.into_iter().map(Into::into).pack())
+                .proposals(proposals.into_iter().map(Into::into).pack())
                 .extension(extension)
                 .build()
                 .as_v0()
         } else {
             packed::Block::new_builder()
-                .header(header)
-                .uncles(
-                    uncles
-                        .into_iter()
-                        .map(Into::into)
-                        .collect::<Vec<packed::UncleBlock>>(),
-                )
-                .transactions(
-                    transactions
-                        .into_iter()
-                        .map(Into::into)
-                        .collect::<Vec<packed::Transaction>>(),
-                )
-                .proposals(
-                    proposals
-                        .into_iter()
-                        .map(Into::into)
-                        .collect::<Vec<packed::ProposalShortId>>(),
-                )
+                .header(header.into())
+                .uncles(uncles.into_iter().map(Into::into).pack())
+                .transactions(transactions.into_iter().map(Into::into).pack())
+                .proposals(proposals.into_iter().map(Into::into).pack())
                 .build()
         }
     }
@@ -1222,10 +1160,10 @@ impl EpochView {
     /// Creates the view from the stored ext.
     pub fn from_ext(ext: packed::EpochExt) -> EpochView {
         EpochView {
-            number: ext.number().into(),
-            start_number: ext.start_number().into(),
-            length: ext.length().into(),
-            compact_target: ext.compact_target().into(),
+            number: ext.number().unpack(),
+            start_number: ext.start_number().unpack(),
+            length: ext.length().unpack(),
+            compact_target: ext.compact_target().unpack(),
         }
     }
 }
@@ -1319,7 +1257,7 @@ impl From<core::BlockEconomicState> for BlockEconomicState {
             issuance: core.issuance.into(),
             miner_reward: core.miner_reward.into(),
             txs_fee: core.txs_fee.into(),
-            finalized_at: core.finalized_at.into(),
+            finalized_at: core.finalized_at.unpack(),
         }
     }
 }
@@ -1330,7 +1268,7 @@ impl From<BlockEconomicState> for core::BlockEconomicState {
             issuance: json.issuance.into(),
             miner_reward: json.miner_reward.into(),
             txs_fee: json.txs_fee.into(),
-            finalized_at: json.finalized_at.into(),
+            finalized_at: json.finalized_at.pack(),
         }
     }
 }
diff --git a/util/jsonrpc-types/src/bytes.rs b/util/jsonrpc-types/src/bytes.rs
index 555a34b8ce..b5b7a6bcf4 100644
--- a/util/jsonrpc-types/src/bytes.rs
+++ b/util/jsonrpc-types/src/bytes.rs
@@ -1,4 +1,4 @@
-use ckb_types::{bytes::Bytes, packed};
+use ckb_types::{bytes::Bytes, packed, prelude::*};
 use faster_hex::{hex_decode, hex_encode};
 use schemars::JsonSchema;
 use std::fmt;
@@ -72,7 +72,7 @@ impl<'a> From<&'a packed::Bytes> for JsonBytes {
 
 impl From<JsonBytes> for packed::Bytes {
     fn from(input: JsonBytes) -> Self {
-        input.0.into()
+        input.0.pack()
     }
 }
 
diff --git a/util/jsonrpc-types/src/cell.rs b/util/jsonrpc-types/src/cell.rs
index 6a5d8c8061..887dbc2ab8 100644
--- a/util/jsonrpc-types/src/cell.rs
+++ b/util/jsonrpc-types/src/cell.rs
@@ -1,6 +1,7 @@
 use crate::{CellOutput, JsonBytes};
 use ckb_types::{
     core::cell::{CellMeta, CellStatus},
+    prelude::Unpack,
     H256,
 };
 use schemars::JsonSchema;
@@ -125,7 +126,7 @@ impl From<CellMeta> for CellInfo {
             data: data.and_then(move |data| {
                 data_hash.map(|hash| CellData {
                     content: JsonBytes::from_bytes(data),
-                    hash: hash.into(),
+                    hash: hash.unpack(),
                 })
             }),
         }
diff --git a/util/jsonrpc-types/src/pool.rs b/util/jsonrpc-types/src/pool.rs
index a0b950d74e..b3d9ea8c7a 100644
--- a/util/jsonrpc-types/src/pool.rs
+++ b/util/jsonrpc-types/src/pool.rs
@@ -67,7 +67,7 @@ pub struct TxPoolInfo {
 impl From<CoreTxPoolInfo> for TxPoolInfo {
     fn from(tx_pool_info: CoreTxPoolInfo) -> Self {
         TxPoolInfo {
-            tip_hash: tx_pool_info.tip_hash.into(),
+            tip_hash: tx_pool_info.tip_hash.unpack(),
             tip_number: tx_pool_info.tip_number.into(),
             pending: (tx_pool_info.pending_size as u64).into(),
             proposed: (tx_pool_info.proposed_size as u64).into(),
@@ -203,11 +203,11 @@ impl From<TxPoolEntryInfo> for TxPoolEntries {
         TxPoolEntries {
             pending: pending
                 .into_iter()
-                .map(|(hash, entry)| (hash.into(), entry.into()))
+                .map(|(hash, entry)| (hash.unpack(), entry.into()))
                 .collect(),
             proposed: proposed
                 .into_iter()
-                .map(|(hash, entry)| (hash.into(), entry.into()))
+                .map(|(hash, entry)| (hash.unpack(), entry.into()))
                 .collect(),
             conflicted: conflicted.iter().map(Unpack::unpack).collect(),
         }
diff --git a/util/jsonrpc-types/src/proposal_short_id.rs b/util/jsonrpc-types/src/proposal_short_id.rs
index 0e480c8a32..3afb79d628 100644
--- a/util/jsonrpc-types/src/proposal_short_id.rs
+++ b/util/jsonrpc-types/src/proposal_short_id.rs
@@ -45,7 +45,7 @@ impl<'a> From<&'a packed::ProposalShortId> for ProposalShortId {
 
 impl From<ProposalShortId> for packed::ProposalShortId {
     fn from(json: ProposalShortId) -> Self {
-        json.into_inner().into()
+        json.into_inner().pack()
     }
 }
 
diff --git a/util/jsonrpc-types/src/tests/blockchain.rs b/util/jsonrpc-types/src/tests/blockchain.rs
index eb217947b2..a82be1a06b 100644
--- a/util/jsonrpc-types/src/tests/blockchain.rs
+++ b/util/jsonrpc-types/src/tests/blockchain.rs
@@ -11,16 +11,16 @@ use crate::{
 fn mock_script(arg: Bytes) -> packed::Script {
     packed::ScriptBuilder::default()
         .code_hash(packed::Byte32::zero())
-        .args(arg)
-        .hash_type(core::ScriptHashType::Data)
+        .args(arg.pack())
+        .hash_type(core::ScriptHashType::Data.into())
         .build()
 }
 
 fn mock_cell_output(arg: Bytes) -> packed::CellOutput {
     packed::CellOutputBuilder::default()
-        .capacity(core::Capacity::zero())
+        .capacity(core::Capacity::zero().pack())
         .lock(packed::Script::default())
-        .type_(Some(mock_script(arg)))
+        .type_(Some(mock_script(arg)).pack())
         .build()
 }
 
@@ -32,16 +32,14 @@ fn mock_full_tx(data: Bytes, arg: Bytes) -> core::TransactionView {
     core::TransactionBuilder::default()
         .inputs(vec![mock_cell_input()])
         .outputs(vec![mock_cell_output(arg.clone())])
-        .outputs_data(vec![data.into()])
-        .witness(arg)
+        .outputs_data(vec![data.pack()])
+        .witness(arg.pack())
         .build()
 }
 
 fn mock_uncle() -> core::UncleBlockView {
     core::BlockBuilder::default()
-        .proposals(Into::<packed::ProposalShortIdVec>::into(vec![
-            packed::ProposalShortId::default(),
-        ]))
+        .proposals(vec![packed::ProposalShortId::default()].pack())
         .build()
         .as_uncle()
 }
diff --git a/util/jsonrpc-types/src/uints.rs b/util/jsonrpc-types/src/uints.rs
index 8e7b9c8470..7889860140 100644
--- a/util/jsonrpc-types/src/uints.rs
+++ b/util/jsonrpc-types/src/uints.rs
@@ -140,27 +140,6 @@ macro_rules! impl_serde_deserialize {
         }
     };
 }
-macro_rules! impl_from_and_into {
-    ($packed:ident, $inner:ident) => {
-        impl From<JsonUint<$inner>> for packed::$packed {
-            fn from(value: JsonUint<$inner>) -> Self {
-                (&value).into()
-            }
-        }
-
-        impl From<&JsonUint<$inner>> for packed::$packed {
-            fn from(value: &JsonUint<$inner>) -> Self {
-                value.value().into()
-            }
-        }
-
-        impl From<packed::$packed> for JsonUint<$inner> {
-            fn from(value: packed::$packed) -> JsonUint<$inner> {
-                Into::<$inner>::into(value).into()
-            }
-        }
-    };
-}
 
 macro_rules! impl_pack_and_unpack {
     ($packed:ident, $inner:ident) => {
@@ -188,10 +167,6 @@ impl_pack_and_unpack!(Uint32, u32);
 impl_pack_and_unpack!(Uint64, u64);
 impl_pack_and_unpack!(Uint128, u128);
 
-impl_from_and_into!(Uint32, u32);
-impl_from_and_into!(Uint64, u64);
-impl_from_and_into!(Uint128, u128);
-
 impl From<core::Capacity> for JsonUint<u64> {
     fn from(value: core::Capacity) -> Self {
         JsonUint(value.as_u64())
diff --git a/util/launcher/Cargo.toml b/util/launcher/Cargo.toml
index 9a7c3f35e5..0d9252346a 100644
--- a/util/launcher/Cargo.toml
+++ b/util/launcher/Cargo.toml
@@ -11,6 +11,7 @@ repository = "https://github.com/nervosnetwork/ckb"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+ckb-types = { path = "../types", version = "= 0.119.0-pre" }
 ckb-store = { path = "../../store", version = "= 0.119.0-pre" }
 ckb-app-config = { path = "../app-config", version = "= 0.119.0-pre" }
 ckb-logger = { path = "../logger", version = "= 0.119.0-pre" }
@@ -35,7 +36,7 @@ ckb-block-filter = { path = "../../block-filter", version = "= 0.119.0-pre" }
 with_sentry = [
     "ckb-sync/with_sentry",
     "ckb-network/with_sentry",
-    "ckb-app-config/with_sentry",
+    "ckb-app-config/with_sentry"
 ]
 portable = ["ckb-shared/portable"]
 march-native = ["ckb-shared/march-native"]
diff --git a/util/launcher/src/lib.rs b/util/launcher/src/lib.rs
index b22d3fa401..2c21a3291d 100644
--- a/util/launcher/src/lib.rs
+++ b/util/launcher/src/lib.rs
@@ -21,12 +21,12 @@ use ckb_network::{
 use ckb_network_alert::alert_relayer::AlertRelayer;
 use ckb_resource::Resource;
 use ckb_rpc::{RpcServer, ServiceBuilder};
-use ckb_shared::{ChainServicesBuilder, Shared};
-
 use ckb_shared::shared_builder::{SharedBuilder, SharedPackage};
+use ckb_shared::{ChainServicesBuilder, Shared};
 use ckb_store::ChainDB;
 use ckb_sync::{BlockFilter, NetTimeProtocol, Relayer, SyncShared, Synchronizer};
 use ckb_tx_pool::service::TxVerificationResult;
+use ckb_types::prelude::*;
 use ckb_verification::GenesisVerifier;
 use ckb_verification_traits::Verifier;
 use std::sync::Arc;
@@ -96,7 +96,7 @@ impl Launcher {
             } else if self.args.block_assembler_advanced
                 || (block_assembler.hash_type == ScriptHashType::Type
                     && block_assembler.args.len() == SECP256K1_BLAKE160_SIGHASH_ALL_ARG_LEN
-                    && check_lock_code_hash(&(&block_assembler.code_hash).into())?)
+                    && check_lock_code_hash(&block_assembler.code_hash.pack())?)
             {
                 if block_assembler.use_binary_version_as_message_prefix {
                     block_assembler.binary_version = self.version.long();
diff --git a/util/light-client-protocol-server/src/components/get_blocks_proof.rs b/util/light-client-protocol-server/src/components/get_blocks_proof.rs
index 547300d2bd..991852309c 100644
--- a/util/light-client-protocol-server/src/components/get_blocks_proof.rs
+++ b/util/light-client-protocol-server/src/components/get_blocks_proof.rs
@@ -96,11 +96,11 @@ impl<'a> GetBlocksProofProcess<'a> {
 
         if ckb2023 {
             let proved_items = (
-                block_headers.into(),
-                uncles_hash.into(),
+                block_headers.pack(),
+                uncles_hash.pack(),
                 packed::BytesOptVec::new_builder().set(extensions).build(),
             );
-            let missing_items = missing.into();
+            let missing_items = missing.pack();
 
             self.protocol.reply_proof::<packed::SendBlocksProofV1>(
                 self.peer,
@@ -111,8 +111,8 @@ impl<'a> GetBlocksProofProcess<'a> {
                 missing_items,
             )
         } else {
-            let proved_items = block_headers.into();
-            let missing_items = missing.into();
+            let proved_items = block_headers.pack();
+            let missing_items = missing.pack();
 
             self.protocol.reply_proof::<packed::SendBlocksProof>(
                 self.peer,
diff --git a/util/light-client-protocol-server/src/components/get_last_state.rs b/util/light-client-protocol-server/src/components/get_last_state.rs
index 643586890c..d6bc3791a7 100644
--- a/util/light-client-protocol-server/src/components/get_last_state.rs
+++ b/util/light-client-protocol-server/src/components/get_last_state.rs
@@ -26,7 +26,7 @@ impl<'a> GetLastStateProcess<'a> {
     }
 
     pub(crate) fn execute(self) -> Status {
-        let subscribe: bool = self.message.subscribe().into();
+        let subscribe: bool = self.message.subscribe().unpack();
         if subscribe {
             self.nc.with_peer_mut(
                 self.peer,
diff --git a/util/light-client-protocol-server/src/components/get_last_state_proof.rs b/util/light-client-protocol-server/src/components/get_last_state_proof.rs
index 61540b8bef..c64592db89 100644
--- a/util/light-client-protocol-server/src/components/get_last_state_proof.rs
+++ b/util/light-client-protocol-server/src/components/get_last_state_proof.rs
@@ -162,7 +162,7 @@ impl<'a> BlockSampler<'a> {
                 let header = packed::VerifiableHeader::new_builder()
                     .header(ancestor_header.data())
                     .uncles_hash(uncles_hash)
-                    .extension(extension)
+                    .extension(Pack::pack(&extension))
                     .parent_chain_root(parent_chain_root)
                     .build();
 
@@ -193,7 +193,7 @@ impl<'a> GetLastStateProofProcess<'a> {
     }
 
     pub(crate) fn execute(self) -> Status {
-        let last_n_blocks: u64 = self.message.last_n_blocks().into();
+        let last_n_blocks: u64 = self.message.last_n_blocks().unpack();
 
         if self.message.difficulties().len() + (last_n_blocks as usize) * 2
             > constant::GET_LAST_STATE_PROOF_LIMIT
@@ -214,13 +214,13 @@ impl<'a> GetLastStateProofProcess<'a> {
             .expect("block should be in store");
 
         let start_block_hash = self.message.start_hash().to_entity();
-        let start_block_number: BlockNumber = self.message.start_number().into();
-        let difficulty_boundary: U256 = self.message.difficulty_boundary().into();
+        let start_block_number: BlockNumber = self.message.start_number().unpack();
+        let difficulty_boundary: U256 = self.message.difficulty_boundary().unpack();
         let mut difficulties = self
             .message
             .difficulties()
             .iter()
-            .map(Into::<U256>::into)
+            .map(|d| Unpack::<U256>::unpack(&d))
             .collect::<Vec<_>>();
 
         let last_block_number = last_block.number();
@@ -356,7 +356,7 @@ impl<'a> GetLastStateProofProcess<'a> {
             (positions, headers)
         };
 
-        let proved_items = headers.into();
+        let proved_items = headers.pack();
 
         self.protocol.reply_proof::<packed::SendLastStateProof>(
             self.peer,
diff --git a/util/light-client-protocol-server/src/components/get_transactions_proof.rs b/util/light-client-protocol-server/src/components/get_transactions_proof.rs
index 715cf01a85..1dd5700b53 100644
--- a/util/light-client-protocol-server/src/components/get_transactions_proof.rs
+++ b/util/light-client-protocol-server/src/components/get_transactions_proof.rs
@@ -104,11 +104,11 @@ impl<'a> GetTransactionsProofProcess<'a> {
             let filtered_block = packed::FilteredBlock::new_builder()
                 .header(block.header().data())
                 .witnesses_root(block.calc_witnesses_root())
-                .transactions(txs)
+                .transactions(txs.pack())
                 .proof(
                     packed::MerkleProof::new_builder()
-                        .indices(merkle_proof.indices())
-                        .lemmas(merkle_proof.lemmas().to_owned())
+                        .indices(merkle_proof.indices().to_owned().pack())
+                        .lemmas(merkle_proof.lemmas().to_owned().pack())
                         .build(),
                 )
                 .build();
@@ -131,10 +131,10 @@ impl<'a> GetTransactionsProofProcess<'a> {
                 packed::FilteredBlockVec::new_builder()
                     .set(filtered_blocks)
                     .build(),
-                uncles_hash.into(),
+                uncles_hash.pack(),
                 packed::BytesOptVec::new_builder().set(extensions).build(),
             );
-            let missing_items = missing.into();
+            let missing_items = missing.pack();
 
             self.protocol
                 .reply_proof::<packed::SendTransactionsProofV1>(
@@ -149,7 +149,7 @@ impl<'a> GetTransactionsProofProcess<'a> {
             let proved_items = packed::FilteredBlockVec::new_builder()
                 .set(filtered_blocks)
                 .build();
-            let missing_items = missing.into();
+            let missing_items = missing.pack();
 
             self.protocol.reply_proof::<packed::SendTransactionsProof>(
                 self.peer,
diff --git a/util/light-client-protocol-server/src/lib.rs b/util/light-client-protocol-server/src/lib.rs
index 94be3c0b53..d2e6bd938e 100644
--- a/util/light-client-protocol-server/src/lib.rs
+++ b/util/light-client-protocol-server/src/lib.rs
@@ -139,7 +139,7 @@ impl LightClientProtocol {
         let tip_header = packed::VerifiableHeader::new_builder()
             .header(tip_block.header().data())
             .uncles_hash(tip_block.calc_uncles_hash())
-            .extension(tip_block.extension())
+            .extension(Pack::pack(&tip_block.extension()))
             .parent_chain_root(parent_chain_root)
             .build();
 
@@ -206,12 +206,12 @@ impl LightClientProtocol {
         let verifiable_last_header = packed::VerifiableHeader::new_builder()
             .header(last_block.data().header())
             .uncles_hash(last_block.calc_uncles_hash())
-            .extension(last_block.extension())
+            .extension(Pack::pack(&last_block.extension()))
             .parent_chain_root(parent_chain_root)
             .build();
         let content = T::new_builder()
             .set_last_header(verifiable_last_header)
-            .set_proof(proof.into())
+            .set_proof(proof.pack())
             .set_proved_items(proved_items)
             .set_missing_items(missing_items)
             .build();
diff --git a/util/light-client-protocol-server/src/tests/components/get_blocks_proof.rs b/util/light-client-protocol-server/src/tests/components/get_blocks_proof.rs
index 981fda9250..a0dc24885e 100644
--- a/util/light-client-protocol-server/src/tests/components/get_blocks_proof.rs
+++ b/util/light-client-protocol-server/src/tests/components/get_blocks_proof.rs
@@ -33,7 +33,7 @@ async fn get_blocks_proof_with_missing_blocks() {
             h256!("0x5"),
         ]
         .into_iter()
-        .map(|h| h.into());
+        .map(|h| h.pack());
         forked_block_hashes.extend(invalid_block_hashes);
         forked_block_hashes
     };
@@ -62,7 +62,7 @@ async fn get_blocks_proof_with_missing_blocks() {
         request_block_hashes.extend_from_slice(&expected_missing_block_hashes[..]);
         let content = packed::GetBlocksProof::new_builder()
             .last_hash(snapshot.tip_header().hash())
-            .block_hashes(request_block_hashes)
+            .block_hashes(request_block_hashes.pack())
             .build();
         packed::LightClientMessage::new_builder()
             .set(content)
diff --git a/util/light-client-protocol-server/src/tests/components/get_last_state_proof.rs b/util/light-client-protocol-server/src/tests/components/get_last_state_proof.rs
index dc50c27bf0..6507668741 100644
--- a/util/light-client-protocol-server/src/tests/components/get_last_state_proof.rs
+++ b/util/light-client-protocol-server/src/tests/components/get_last_state_proof.rs
@@ -30,9 +30,9 @@ async fn get_last_state_proof_with_the_genesis_block() {
         let content = packed::GetLastStateProof::new_builder()
             .last_hash(tip_header.hash())
             .start_hash(genesis_header.hash())
-            .start_number(0u64)
-            .last_n_blocks(10u64)
-            .difficulty_boundary(genesis_header.difficulty())
+            .start_number(0u64.pack())
+            .last_n_blocks(10u64.pack())
+            .difficulty_boundary(genesis_header.difficulty().pack())
             .build();
         packed::LightClientMessage::new_builder()
             .set(content)
@@ -64,7 +64,7 @@ async fn get_last_state_proof_with_the_genesis_block() {
     {
         let parent_chain_root = verifiable_tip_header.parent_chain_root();
         let proof: MMRProof = {
-            let mmr_size = leaf_index_to_mmr_size(parent_chain_root.end_number().into());
+            let mmr_size = leaf_index_to_mmr_size(parent_chain_root.end_number().unpack());
             let proof = content.proof().into_iter().collect();
             MMRProof::new(mmr_size, proof)
         };
diff --git a/util/light-client-protocol-server/src/tests/components/get_transactions_proof.rs b/util/light-client-protocol-server/src/tests/components/get_transactions_proof.rs
index 021872d962..eb8e280646 100644
--- a/util/light-client-protocol-server/src/tests/components/get_transactions_proof.rs
+++ b/util/light-client-protocol-server/src/tests/components/get_transactions_proof.rs
@@ -70,7 +70,7 @@ async fn get_transactions_proof_with_missing_txs() {
 
     let tx3_hash = h256!("0x1");
 
-    let expected_missing_tx_hashes = vec![tx2.hash(), (&tx3_hash).into()];
+    let expected_missing_tx_hashes = vec![tx2.hash(), tx3_hash.pack()];
 
     let snapshot = chain.shared().snapshot();
 
@@ -84,7 +84,7 @@ async fn get_transactions_proof_with_missing_txs() {
     let data = {
         let content = packed::GetTransactionsProof::new_builder()
             .last_hash(snapshot.tip_header().hash())
-            .tx_hashes(vec![tx1.hash(), tx2.hash(), tx3_hash.into()])
+            .tx_hashes(vec![tx1.hash(), tx2.hash(), tx3_hash.pack()].pack())
             .build();
         packed::LightClientMessage::new_builder()
             .set(content)
diff --git a/util/light-client-protocol-server/src/tests/prelude.rs b/util/light-client-protocol-server/src/tests/prelude.rs
index 2b35b8a7b6..3fc94a7068 100644
--- a/util/light-client-protocol-server/src/tests/prelude.rs
+++ b/util/light-client-protocol-server/src/tests/prelude.rs
@@ -66,7 +66,7 @@ impl SnapshotExt for Snapshot {
             packed::VerifiableHeader::new_builder()
                 .header(block.data().header())
                 .uncles_hash(block.calc_uncles_hash())
-                .extension(block.extension())
+                .extension(Pack::pack(&block.extension()))
                 .parent_chain_root(parent_chain_root)
                 .build()
         })
diff --git a/util/light-client-protocol-server/src/tests/utils/chain.rs b/util/light-client-protocol-server/src/tests/utils/chain.rs
index a88239dac6..03e37e704b 100644
--- a/util/light-client-protocol-server/src/tests/utils/chain.rs
+++ b/util/light-client-protocol-server/src/tests/utils/chain.rs
@@ -36,7 +36,7 @@ impl MockChain {
         let always_success_tx = TransactionView::new_advanced_builder()
             .input(packed::CellInput::new(packed::OutPoint::null(), 0))
             .output(always_success_cell.clone())
-            .output_data(always_success_cell_data)
+            .output_data(always_success_cell_data.pack())
             .witness(always_success_script.clone().into_witness())
             .build();
         let always_success_out_point = packed::OutPoint::new(always_success_tx.hash(), 0);
@@ -48,8 +48,8 @@ impl MockChain {
 
         let (shared, mut pack) = {
             let genesis = BlockView::new_advanced_builder()
-                .timestamp(unix_time_as_millis())
-                .compact_target(DIFF_TWO)
+                .timestamp(unix_time_as_millis().pack())
+                .compact_target(DIFF_TWO.pack())
                 .transaction(always_success_tx)
                 .dao(dao)
                 .build();
@@ -66,7 +66,7 @@ impl MockChain {
                 .build();
             let config = BlockAssemblerConfig {
                 // always success
-                code_hash: always_success_script.code_hash().into(),
+                code_hash: always_success_script.code_hash().unpack(),
                 args: Default::default(),
                 hash_type: ScriptHashType::Data,
                 message: Default::default(),
@@ -197,12 +197,12 @@ impl MockChain {
         let block = snapshot.get_block_by_number(block_number).unwrap();
         let cellbase = block.transaction(0).unwrap();
         let input = packed::CellInput::new(packed::OutPoint::new(cellbase.hash(), 0), 0);
-        let input_capacity: Capacity = cellbase.output(0).unwrap().capacity().into();
+        let input_capacity: Capacity = cellbase.output(0).unwrap().capacity().unpack();
         let output_capacity = input_capacity.safe_sub(1000u32).unwrap();
         let header_dep = block.hash();
         let (_, _, always_success_script) = always_success_cell();
         let output = packed::CellOutput::new_builder()
-            .capacity(output_capacity)
+            .capacity(output_capacity.pack())
             .lock(always_success_script.to_owned())
             .build();
         TransactionView::new_advanced_builder()
@@ -210,7 +210,7 @@ impl MockChain {
             .header_dep(header_dep)
             .input(input)
             .output(output)
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build()
     }
 }
diff --git a/util/migrate/src/migrations/add_number_hash_mapping.rs b/util/migrate/src/migrations/add_number_hash_mapping.rs
index e752957e4b..cf07ead605 100644
--- a/util/migrate/src/migrations/add_number_hash_mapping.rs
+++ b/util/migrate/src/migrations/add_number_hash_mapping.rs
@@ -20,7 +20,7 @@ impl Migration for AddNumberHashMapping {
         multi_thread_migration! {
             {
                 for number in i * chunk_size..end {
-                    let block_number: packed::Uint64 = number.into();
+                    let block_number: packed::Uint64 = number.pack();
                     let raw_hash = chain_db.get(COLUMN_INDEX, block_number.as_slice()).expect("DB data integrity");
                     let txs_len = chain_db.get_iter(
                         COLUMN_BLOCK_BODY,
@@ -29,7 +29,7 @@ impl Migration for AddNumberHashMapping {
                     .take_while(|(key, _)| key.starts_with(&raw_hash))
                     .count();
 
-                    let raw_txs_len: packed::Uint32 = (txs_len as u32).into();
+                    let raw_txs_len: packed::Uint32 = (txs_len as u32).pack();
 
                     let mut raw_key = Vec::with_capacity(40);
                     raw_key.write_all(block_number.as_slice()).expect("write_all block_number");
diff --git a/util/migrate/src/migrations/cell.rs b/util/migrate/src/migrations/cell.rs
index 9d83c802cc..7dee3fc991 100644
--- a/util/migrate/src/migrations/cell.rs
+++ b/util/migrate/src/migrations/cell.rs
@@ -99,23 +99,23 @@ fn insert_block_cell(batch: &mut StoreWriteBatch, block: &BlockView) {
                 .map(move |(index, (cell_output, data))| {
                     let out_point = packed::OutPoint::new_builder()
                         .tx_hash(tx_hash.clone())
-                        .index(index)
+                        .index(index.pack())
                         .build();
 
                     let entry = packed::CellEntryBuilder::default()
                         .output(cell_output)
                         .block_hash(block_hash.clone())
-                        .block_number(block_number)
-                        .block_epoch(block_epoch)
-                        .index(tx_index)
-                        .data_size(data.len() as u64)
+                        .block_number(block_number.pack())
+                        .block_epoch(block_epoch.pack())
+                        .index(tx_index.pack())
+                        .data_size((data.len() as u64).pack())
                         .build();
 
                     let data_entry = if !data.is_empty() {
                         let data_hash = packed::CellOutput::calc_data_hash(&data);
                         Some(
                             packed::CellDataEntryBuilder::default()
-                                .output_data(data)
+                                .output_data(data.pack())
                                 .output_data_hash(data_hash)
                                 .build(),
                         )
diff --git a/util/migrate/src/migrations/set_2019_block_cycle_zero.rs b/util/migrate/src/migrations/set_2019_block_cycle_zero.rs
index 58c4773d90..e45f6fd253 100644
--- a/util/migrate/src/migrations/set_2019_block_cycle_zero.rs
+++ b/util/migrate/src/migrations/set_2019_block_cycle_zero.rs
@@ -6,7 +6,7 @@ use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
     core::hardfork::HardForks,
     packed,
-    prelude::{Entity, FromSliceShouldBeOk, Reader},
+    prelude::{Entity, FromSliceShouldBeOk, Pack, Reader},
 };
 
 const VERSION: &str = "20231101000000";
@@ -42,9 +42,9 @@ impl Migration for BlockExt2019ToZero {
             return Ok(chain_db.into_inner());
         }
 
-        let hard_fork_epoch_number: packed::Uint64 = limit_epoch.into();
+        let hard_fork_epoch_number: packed::Uint64 = limit_epoch.pack();
         let tip_header = chain_db.get_tip_header().expect("db must have tip header");
-        let tip_epoch_number: packed::Uint64 = tip_header.epoch().into();
+        let tip_epoch_number = tip_header.epoch().pack();
 
         let header = if tip_epoch_number < hard_fork_epoch_number {
             Some(tip_header)
diff --git a/util/migrate/src/tests.rs b/util/migrate/src/tests.rs
index eda61099cd..f8335c6fc0 100644
--- a/util/migrate/src/tests.rs
+++ b/util/migrate/src/tests.rs
@@ -42,9 +42,9 @@ fn test_mock_migration() {
     // insert block
     {
         let hash = genesis.hash();
-        let header: packed::HeaderView = genesis.header().into();
+        let header = genesis.header().pack();
         let number = header.data().raw().number();
-        let uncles: packed::UncleBlockVecView = genesis.uncles().into();
+        let uncles = genesis.uncles().pack();
         let proposals = genesis.data().proposals();
         db_txn
             .put(COLUMN_INDEX, number.as_slice(), hash.as_slice())
@@ -65,9 +65,9 @@ fn test_mock_migration() {
         for (index, tx) in genesis.transactions().into_iter().enumerate() {
             let key = packed::TransactionKey::new_builder()
                 .block_hash(hash.clone())
-                .index(index)
+                .index(index.pack())
                 .build();
-            let tx_data: packed::TransactionView = tx.into();
+            let tx_data = tx.pack();
             db_txn
                 .put(COLUMN_BLOCK_BODY, key.as_slice(), tx_data.as_slice())
                 .unwrap();
@@ -100,10 +100,10 @@ fn test_mock_migration() {
             .put(
                 COLUMN_EPOCH,
                 epoch_ext.last_block_hash_in_previous_epoch().as_slice(),
-                Into::<packed::EpochExt>::into(&epoch_ext).as_slice(),
+                epoch_ext.pack().as_slice(),
             )
             .unwrap();
-        let epoch_number: packed::Uint64 = epoch_ext.number().into();
+        let epoch_number: packed::Uint64 = epoch_ext.number().pack();
         db_txn
             .put(
                 COLUMN_EPOCH,
@@ -130,7 +130,7 @@ fn test_mock_migration() {
             .put(
                 COLUMN_BLOCK_EXT,
                 genesis.header().hash().as_slice(),
-                Into::<packed::BlockExtV1>::into(ext).as_slice(),
+                ext.pack().as_slice(),
             )
             .unwrap()
     }
@@ -141,7 +141,7 @@ fn test_mock_migration() {
             .put(
                 COLUMN_META,
                 META_CURRENT_EPOCH_KEY,
-                Into::<packed::EpochExt>::into(epoch_ext).as_slice(),
+                epoch_ext.pack().as_slice(),
             )
             .unwrap()
     }
diff --git a/util/network-alert/src/alert_relayer.rs b/util/network-alert/src/alert_relayer.rs
index 305af17771..e4b8f506c8 100644
--- a/util/network-alert/src/alert_relayer.rs
+++ b/util/network-alert/src/alert_relayer.rs
@@ -86,7 +86,7 @@ impl CKBProtocolHandler for AlertRelayer {
     ) {
         self.clear_expired_alerts();
         for alert in self.notifier.lock().received_alerts() {
-            let alert_id: u32 = alert.as_reader().raw().id().into();
+            let alert_id: u32 = alert.as_reader().raw().id().unpack();
             trace!("Send alert {} to peer {}", alert_id, peer_index);
             if let Err(err) = nc.quick_send_message_to(peer_index, alert.as_bytes()) {
                 debug!("alert_relayer send alert when connected error: {:?}", err);
@@ -141,7 +141,7 @@ impl CKBProtocolHandler for AlertRelayer {
                 return;
             }
         };
-        let alert_id = alert.as_reader().raw().id().into();
+        let alert_id = alert.as_reader().raw().id().unpack();
         trace!("ReceiveD alert {} from peer {}", alert_id, peer_index);
         // ignore alert
         if self.notifier.lock().has_received(alert_id) {
diff --git a/util/network-alert/src/notifier.rs b/util/network-alert/src/notifier.rs
index d684f149a3..363d5b45e3 100644
--- a/util/network-alert/src/notifier.rs
+++ b/util/network-alert/src/notifier.rs
@@ -1,7 +1,7 @@
 //! notifier module
 use ckb_logger::{debug, error};
 use ckb_notify::NotifyController;
-use ckb_types::packed::Alert;
+use ckb_types::{packed::Alert, prelude::*};
 use lru::LruCache;
 use semver::Version;
 use std::collections::HashMap;
@@ -91,8 +91,8 @@ impl Notifier {
 
     /// Add an alert
     pub fn add(&mut self, alert: &Alert) {
-        let alert_id = alert.raw().id().into();
-        let alert_cancel = alert.raw().cancel().into();
+        let alert_id = alert.raw().id().unpack();
+        let alert_cancel = alert.raw().cancel().unpack();
         if self.has_received(alert_id) {
             return;
         }
@@ -116,7 +116,7 @@ impl Notifier {
         self.noticed_alerts.push(alert.clone());
         // sort by priority
         self.noticed_alerts.sort_by_key(|a| {
-            let priority: u32 = a.raw().priority().into();
+            let priority: u32 = a.raw().priority().unpack();
             std::u32::MAX - priority
         });
     }
@@ -126,7 +126,7 @@ impl Notifier {
         self.cancel_filter.put(cancel_id, ());
         self.received_alerts.remove(&cancel_id);
         self.noticed_alerts.retain(|a| {
-            let id: u32 = a.raw().id().into();
+            let id: u32 = a.raw().id().unpack();
             id != cancel_id
         });
     }
@@ -134,11 +134,11 @@ impl Notifier {
     /// Clear all expired alerts
     pub fn clear_expired_alerts(&mut self, now: u64) {
         self.received_alerts.retain(|_id, alert| {
-            let notice_until: u64 = alert.raw().notice_until().into();
+            let notice_until: u64 = alert.raw().notice_until().unpack();
             notice_until > now
         });
         self.noticed_alerts.retain(|a| {
-            let notice_until: u64 = a.raw().notice_until().into();
+            let notice_until: u64 = a.raw().notice_until().unpack();
             notice_until > now
         });
     }
diff --git a/util/network-alert/src/tests/generate_alert_signature.rs b/util/network-alert/src/tests/generate_alert_signature.rs
index 77a8a3f808..366e9ef068 100644
--- a/util/network-alert/src/tests/generate_alert_signature.rs
+++ b/util/network-alert/src/tests/generate_alert_signature.rs
@@ -25,25 +25,25 @@ fn test_signing_alert_using_dummy_keypair() {
     let verifier = Verifier::new(config);
     let raw_alert = packed::RawAlert::new_builder()
         // 3 months later
-        .notice_until(1681574400000u64 )
-        .id(20230001u32 )
-        .cancel(0u32 )
-        .priority(20u32 )
-        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.")
-        .min_version(Some("0.105.0-pre"))
-        .max_version(Some("0.105.1"))
+        .notice_until(1681574400000u64.pack())
+        .id(20230001u32.pack())
+        .cancel(0u32.pack())
+        .priority(20u32.pack())
+        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.".pack())
+        .min_version(Some("0.105.0-pre").pack())
+        .max_version(Some("0.105.1").pack())
         .build();
 
     let hash = raw_alert.calc_alert_hash();
     let privkey = DUMMY_PRIVKEY.parse::<Privkey>().unwrap();
-    let signature: packed::Bytes = privkey
-        .sign_recoverable(&(&hash).into())
+    let signature = privkey
+        .sign_recoverable(&hash.unpack())
         .unwrap()
         .serialize()
-        .into();
+        .pack();
     let alert = packed::Alert::new_builder()
         .raw(raw_alert)
-        .signatures(vec![signature.clone()])
+        .signatures(vec![signature.clone()].pack())
         .build();
     let alert_json = Alert::from(alert.clone());
     println!(
@@ -61,13 +61,13 @@ fn test_alert_20230001() {
     let verifier = Verifier::new(config);
     let raw_alert = packed::RawAlert::new_builder()
         // 3 months later
-        .notice_until(1681574400000u64 )
-        .id(20230001u32 )
-        .cancel(0u32 )
-        .priority(20u32 )
-        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.")
-        .min_version(Some("0.105.0-pre"))
-        .max_version(Some("0.105.1"))
+        .notice_until(1681574400000u64.pack())
+        .id(20230001u32.pack())
+        .cancel(0u32.pack())
+        .priority(20u32.pack())
+        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.".pack())
+        .min_version(Some("0.105.0-pre").pack())
+        .max_version(Some("0.105.1").pack())
         .build();
 
     let signatures = [
@@ -76,7 +76,7 @@ fn test_alert_20230001() {
     ].iter().map(|hex| {
         let mut buf = vec![0u8; hex.len() / 2];
         hex_decode(hex.as_bytes(), &mut buf).expect("valid hex");
-        buf
+        buf.pack()
     }).fold(packed::BytesVec::new_builder(), |builder, item| {
         builder.push(item)
     }).build();
diff --git a/util/network-alert/src/tests/test_notifier.rs b/util/network-alert/src/tests/test_notifier.rs
index 7d6d97329e..86c77b0982 100644
--- a/util/network-alert/src/tests/test_notifier.rs
+++ b/util/network-alert/src/tests/test_notifier.rs
@@ -13,11 +13,11 @@ fn build_alert(
     notice_until: u64,
 ) -> packed::Alert {
     let raw = packed::RawAlert::new_builder()
-        .id(id)
-        .cancel(cancel)
-        .min_version(min_ver)
-        .max_version(max_ver)
-        .notice_until(notice_until)
+        .id(id.pack())
+        .cancel(cancel.pack())
+        .min_version(min_ver.pack())
+        .max_version(max_ver.pack())
+        .notice_until(notice_until.pack())
         .build();
     packed::Alert::new_builder().raw(raw).build()
 }
diff --git a/util/network-alert/src/tests/test_verifier.rs b/util/network-alert/src/tests/test_verifier.rs
index 1a0c3d8d60..6060eb70d6 100644
--- a/util/network-alert/src/tests/test_verifier.rs
+++ b/util/network-alert/src/tests/test_verifier.rs
@@ -15,15 +15,15 @@ fn test_veirifer() {
             .collect(),
     };
     let verifier = Verifier::new(config);
-    let raw_alert = packed::RawAlert::new_builder().id(1u32).build();
+    let raw_alert = packed::RawAlert::new_builder().id(1u32.pack()).build();
     let hash = raw_alert.calc_alert_hash();
     let signatures = keypairs
         .iter()
-        .map(|(privkey, _)| privkey.sign_recoverable(&(&hash).into()))
+        .map(|(privkey, _)| privkey.sign_recoverable(&hash.unpack()))
         .collect::<Result<Vec<_>, _>>()
         .expect("sign alert")
         .iter()
-        .map(|sig| sig.serialize())
+        .map(|sig| sig.serialize().pack())
         .fold(packed::BytesVec::new_builder(), |builder, item| {
             builder.push(item)
         })
diff --git a/util/reward-calculator/src/tests.rs b/util/reward-calculator/src/tests.rs
index 0df6e50116..6ab899fbf9 100644
--- a/util/reward-calculator/src/tests.rs
+++ b/util/reward-calculator/src/tests.rs
@@ -6,6 +6,7 @@ use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
     core::{BlockBuilder, BlockExt, EpochNumberWithFraction, HeaderBuilder, TransactionBuilder},
     packed::ProposalShortId,
+    prelude::*,
 };
 use std::collections::HashSet;
 use tempfile::TempDir;
@@ -128,12 +129,12 @@ fn test_proposal_reward() {
         .tx_proposal_window(ProposalWindow(2, 5))
         .build();
 
-    let tx1 = TransactionBuilder::default().version(100u32).build();
-    let tx2 = TransactionBuilder::default().version(200u32).build();
-    let tx3 = TransactionBuilder::default().version(300u32).build();
-    let tx4 = TransactionBuilder::default().version(400u32).build();
-    let tx5 = TransactionBuilder::default().version(500u32).build();
-    let tx6 = TransactionBuilder::default().version(600u32).build();
+    let tx1 = TransactionBuilder::default().version(100u32.pack()).build();
+    let tx2 = TransactionBuilder::default().version(200u32.pack()).build();
+    let tx3 = TransactionBuilder::default().version(300u32.pack()).build();
+    let tx4 = TransactionBuilder::default().version(400u32.pack()).build();
+    let tx5 = TransactionBuilder::default().version(500u32.pack()).build();
+    let tx6 = TransactionBuilder::default().version(600u32.pack()).build();
 
     let p1 = tx1.proposal_short_id();
     let p2 = tx2.proposal_short_id();
@@ -145,8 +146,8 @@ fn test_proposal_reward() {
     let block_10 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(10u64)
-                .epoch(EpochNumberWithFraction::new(1, 10, 1000))
+                .number(10u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 10, 1000).pack())
                 .build(),
         )
         .proposal(p1.clone())
@@ -159,8 +160,8 @@ fn test_proposal_reward() {
     let block_11 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(11u64)
-                .epoch(EpochNumberWithFraction::new(1, 11, 1000))
+                .number(11u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 11, 1000).pack())
                 .parent_hash(block_10.hash())
                 .build(),
         )
@@ -171,8 +172,8 @@ fn test_proposal_reward() {
     let block_12 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(12u64)
-                .epoch(EpochNumberWithFraction::new(1, 12, 1000))
+                .number(12u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 12, 1000).pack())
                 .parent_hash(block_11.hash())
                 .build(),
         )
@@ -182,8 +183,8 @@ fn test_proposal_reward() {
     let block_13 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(13u64)
-                .epoch(EpochNumberWithFraction::new(1, 13, 1000))
+                .number(13u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 13, 1000).pack())
                 .parent_hash(block_12.hash())
                 .build(),
         )
@@ -194,8 +195,8 @@ fn test_proposal_reward() {
     let block_14 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(14u64)
-                .epoch(EpochNumberWithFraction::new(1, 14, 1000))
+                .number(14u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 14, 1000).pack())
                 .parent_hash(block_13.hash())
                 .build(),
         )
@@ -207,8 +208,8 @@ fn test_proposal_reward() {
     let block_15 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(15u64)
-                .epoch(EpochNumberWithFraction::new(1, 15, 1000))
+                .number(15u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 15, 1000).pack())
                 .parent_hash(block_14.hash())
                 .build(),
         )
@@ -218,8 +219,8 @@ fn test_proposal_reward() {
     let block_16 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(16u64)
-                .epoch(EpochNumberWithFraction::new(1, 16, 1000))
+                .number(16u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 16, 1000).pack())
                 .parent_hash(block_15.hash())
                 .build(),
         )
@@ -227,8 +228,8 @@ fn test_proposal_reward() {
     let block_17 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(17u64)
-                .epoch(EpochNumberWithFraction::new(1, 17, 1000))
+                .number(17u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 17, 1000).pack())
                 .parent_hash(block_16.hash())
                 .build(),
         )
@@ -236,8 +237,8 @@ fn test_proposal_reward() {
     let block_18 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(18u64)
-                .epoch(EpochNumberWithFraction::new(1, 18, 1000))
+                .number(18u64.pack())
+                .epoch(EpochNumberWithFraction::new(1, 18, 1000).pack())
                 .parent_hash(block_17.hash())
                 .build(),
         )
diff --git a/util/rich-indexer/src/indexer/insert.rs b/util/rich-indexer/src/indexer/insert.rs
index 4ede859f26..9c8831b347 100644
--- a/util/rich-indexer/src/indexer/insert.rs
+++ b/util/rich-indexer/src/indexer/insert.rs
@@ -405,7 +405,7 @@ pub(crate) async fn query_output_cell(
     tx: &mut Transaction<'_, Any>,
 ) -> Result<Option<(i64, CellOutput, Bytes)>, Error> {
     let output_tx_hash = out_point.tx_hash().raw_data().to_vec();
-    let output_index: u32 = out_point.index().into();
+    let output_index: u32 = out_point.index().unpack();
 
     let row = sqlx::query(
         r#"
@@ -444,7 +444,7 @@ pub(crate) async fn query_output_id(
     tx: &mut Transaction<'_, Any>,
 ) -> Result<Option<i64>, Error> {
     let output_tx_hash = out_point.tx_hash().raw_data().to_vec();
-    let output_index: u32 = out_point.index().into();
+    let output_index: u32 = out_point.index().unpack();
 
     sqlx::query(
         r#"
@@ -514,7 +514,7 @@ pub(crate) fn build_output_cell_rows(
     data: &Bytes,
     output_cell_rows: &mut Vec<OutputCellRow>,
 ) {
-    let cell_capacity: u64 = cell.capacity().into();
+    let cell_capacity: u64 = cell.capacity().unpack();
     let cell_row = (
         output_index as i32,
         cell_capacity as i64,
@@ -563,7 +563,7 @@ pub(crate) fn build_input_rows(
     input_index: usize,
     input_rows: &mut Vec<(i64, Vec<u8>, i32)>,
 ) {
-    let since: u64 = input.since().into();
+    let since: u64 = input.since().unpack();
     let input_row = (output_id, since.to_be_bytes().to_vec(), input_index as i32);
     input_rows.push(input_row);
 }
@@ -585,10 +585,10 @@ fn build_cell_output(row: Option<AnyRow>) -> Option<(i64, CellOutput, Bytes)> {
 
     let mut lock_builder = ScriptBuilder::default();
     if let Some(lock_code_hash) = lock_code_hash {
-        lock_builder = lock_builder.code_hash(to_fixed_array::<32>(&lock_code_hash[0..32]));
+        lock_builder = lock_builder.code_hash(to_fixed_array::<32>(&lock_code_hash[0..32]).pack());
     }
     if let Some(lock_args) = lock_args {
-        lock_builder = lock_builder.args(lock_args);
+        lock_builder = lock_builder.args(lock_args.pack());
     }
     if let Some(lock_hash_type) = lock_hash_type {
         lock_builder = lock_builder.hash_type(Byte::new(lock_hash_type as u8));
@@ -597,10 +597,10 @@ fn build_cell_output(row: Option<AnyRow>) -> Option<(i64, CellOutput, Bytes)> {
 
     let mut type_builder = ScriptBuilder::default();
     if let Some(type_code_hash) = type_code_hash {
-        type_builder = type_builder.code_hash(to_fixed_array::<32>(&type_code_hash[0..32]));
+        type_builder = type_builder.code_hash(to_fixed_array::<32>(&type_code_hash[0..32]).pack());
     }
     if let Some(type_args) = type_args {
-        type_builder = type_builder.args(type_args);
+        type_builder = type_builder.args(type_args.pack());
     }
     if let Some(type_hash_type) = type_hash_type {
         type_builder = type_builder.hash_type(Byte::new(type_hash_type as u8));
@@ -608,9 +608,9 @@ fn build_cell_output(row: Option<AnyRow>) -> Option<(i64, CellOutput, Bytes)> {
     let type_script = type_builder.build();
 
     let cell_output = CellOutput::new_builder()
-        .capacity(capacity as u64)
+        .capacity((capacity as u64).pack())
         .lock(lock_script)
-        .type_(Some(type_script))
+        .type_(Some(type_script).pack())
         .build();
 
     Some((id, cell_output, data.into()))
diff --git a/util/rich-indexer/src/indexer/mod.rs b/util/rich-indexer/src/indexer/mod.rs
index 365e8c5040..32c395f775 100644
--- a/util/rich-indexer/src/indexer/mod.rs
+++ b/util/rich-indexer/src/indexer/mod.rs
@@ -11,6 +11,7 @@ use ckb_indexer_sync::{CustomFilters, Error, IndexerSync, Pool};
 use ckb_types::{
     core::{BlockNumber, BlockView, TransactionView},
     packed::Byte32,
+    prelude::*,
     H256,
 };
 use sqlx::{Any, Transaction};
@@ -67,7 +68,7 @@ impl IndexerSync for RichIndexer {
         );
         indexer_handle
             .get_indexer_tip()
-            .map(|tip| tip.map(|tip| (tip.block_number.value(), tip.block_hash.0.into())))
+            .map(|tip| tip.map(|tip| (tip.block_number.value(), tip.block_hash.0.pack())))
             .map_err(|err| Error::DB(err.to_string()))
     }
 
@@ -189,7 +190,7 @@ impl AsyncRichIndexer {
         for (output_index, (cell, data)) in tx_view.outputs_with_data_iter().enumerate() {
             if self
                 .custom_filters
-                .is_cell_filter_match(&cell, &(&data).into())
+                .is_cell_filter_match(&cell, &data.pack())
             {
                 build_output_cell_rows(&cell, output_index, &data, &mut output_cell_rows);
                 build_script_set(&cell, &mut script_set).await;
@@ -206,7 +207,7 @@ impl AsyncRichIndexer {
                     {
                         if self
                             .custom_filters
-                            .is_cell_filter_match(&output, &output_data.into())
+                            .is_cell_filter_match(&output, &output_data.pack())
                         {
                             build_input_rows(output_id, &input, input_index, &mut input_rows);
                             is_tx_matched = true;
diff --git a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs
index 9eb77805ba..100a5eaca0 100644
--- a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs
+++ b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells.rs
@@ -118,8 +118,8 @@ impl AsyncRichIndexerHandle {
             dead_cells = pool
                 .dead_cells()
                 .map(|out_point| {
-                    let tx_hash: H256 = out_point.tx_hash().into();
-                    (tx_hash.as_bytes().to_vec(), out_point.index().into())
+                    let tx_hash: H256 = out_point.tx_hash().unpack();
+                    (tx_hash.as_bytes().to_vec(), out_point.index().unpack())
                 })
                 .collect::<Vec<(_, u32)>>()
         }
@@ -249,30 +249,28 @@ impl AsyncRichIndexerHandle {
 
 fn build_indexer_cell(row: &AnyRow) -> IndexerCell {
     let out_point = OutPointBuilder::default()
-        .tx_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("tx_hash")))
-        .index(row.get::<i32, _>("output_index") as u32)
+        .tx_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("tx_hash")).pack())
+        .index((row.get::<i32, _>("output_index") as u32).pack())
         .build();
     let lock_script = ScriptBuilder::default()
-        .code_hash(to_fixed_array::<32>(
-            &row.get::<Vec<u8>, _>("lock_code_hash"),
-        ))
-        .hash_type(row.get::<i16, _>("lock_hash_type") as u8)
-        .args(row.get::<Vec<u8>, _>("lock_args"))
+        .code_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("lock_code_hash")).pack())
+        .hash_type((row.get::<i16, _>("lock_hash_type") as u8).into())
+        .args(row.get::<Vec<u8>, _>("lock_args").pack())
         .build();
     let type_script = row
         .get::<Option<Vec<u8>>, _>("type_code_hash")
         .as_ref()
         .map(|value| {
             ScriptBuilder::default()
-                .code_hash(to_fixed_array::<32>(value))
-                .hash_type(row.get::<Option<i16>, _>("type_hash_type").unwrap() as u8)
-                .args(row.get::<Option<Vec<u8>>, _>("type_args").unwrap())
+                .code_hash(to_fixed_array::<32>(value).pack())
+                .hash_type((row.get::<Option<i16>, _>("type_hash_type").unwrap() as u8).into())
+                .args(row.get::<Option<Vec<u8>>, _>("type_args").unwrap().pack())
                 .build()
         });
     let output = CellOutputBuilder::default()
-        .capacity(row.get::<i64, _>("capacity") as u64)
+        .capacity((row.get::<i64, _>("capacity") as u64).pack())
         .lock(lock_script)
-        .type_(type_script)
+        .type_(type_script.pack())
         .build();
 
     IndexerCell {
diff --git a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs
index 6b87b2681b..5a14d90592 100644
--- a/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs
+++ b/util/rich-indexer/src/indexer_handle/async_indexer_handle/get_cells_capacity.rs
@@ -5,6 +5,7 @@ use crate::store::SQLXPool;
 use ckb_indexer_sync::Error;
 use ckb_jsonrpc_types::{IndexerCellsCapacity, IndexerSearchKey};
 use ckb_jsonrpc_types::{IndexerScriptType, IndexerSearchMode};
+use ckb_types::prelude::*;
 use sql_builder::{name, name::SqlName, SqlBuilder};
 use sqlx::Row;
 
@@ -82,8 +83,8 @@ impl AsyncRichIndexerHandle {
             dead_cells = pool
                 .dead_cells()
                 .map(|out_point| {
-                    let tx_hash: H256 = out_point.tx_hash().into();
-                    (tx_hash.as_bytes().to_vec(), out_point.index().into())
+                    let tx_hash: H256 = out_point.tx_hash().unpack();
+                    (tx_hash.as_bytes().to_vec(), out_point.index().unpack())
                 })
                 .collect::<Vec<(_, u32)>>()
         }
diff --git a/util/rich-indexer/src/tests/insert.rs b/util/rich-indexer/src/tests/insert.rs
index 7980dd75a2..1c8fc9e26a 100644
--- a/util/rich-indexer/src/tests/insert.rs
+++ b/util/rich-indexer/src/tests/insert.rs
@@ -8,7 +8,7 @@ use ckb_types::{
         capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
         ScriptHashType, TransactionBuilder,
     },
-    packed::{self, CellInput, CellOutputBuilder, OutPoint, Script, ScriptBuilder},
+    packed::{CellInput, CellOutputBuilder, OutPoint, Script, ScriptBuilder},
     H256,
 };
 use tokio::test;
@@ -81,27 +81,27 @@ async fn with_custom_block_filter() {
     let indexer_handle = AsyncRichIndexerHandle::new(storage, None, usize::MAX);
 
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"lock_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"lock_script1".to_vec()).pack())
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script2".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script2".to_vec()).pack())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script1".to_vec()).pack())
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"type_script2".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"type_script2".to_vec()).pack())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -109,80 +109,80 @@ async fn with_custom_block_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()))
+                .type_(Some(type_script1.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()))
+                .type_(Some(type_script2.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0).build())
+        .header(HeaderBuilder::default().number(0.pack()).build())
         .build();
     indexer.append(&block0).await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
     assert_eq!(0u64, tip.block_number.value());
-    assert_eq!(block0.hash(), tip.block_hash.into());
+    assert_eq!(block0.hash(), tip.block_hash.pack());
 
     let cellbase1 = TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(1))
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx10 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1))
+                .type_(Some(type_script1).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx11 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script2)
-                .type_(Some(type_script2))
+                .type_(Some(type_script2).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let block1 = BlockBuilder::default()
@@ -191,13 +191,11 @@ async fn with_custom_block_filter() {
         .transaction(tx11)
         .header(
             HeaderBuilder::default()
-                .number(1)
+                .number(1.pack())
                 .parent_hash(block0.hash())
-                .epoch(EpochNumberWithFraction::new(
-                    block0.number() + 1,
-                    block0.number(),
-                    1000,
-                ))
+                .epoch(
+                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).pack(),
+                )
                 .build(),
         )
         .build();
@@ -205,7 +203,7 @@ async fn with_custom_block_filter() {
     indexer.append(&block1).await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
     assert_eq!(1, tip.block_number.value());
-    assert_eq!(block1.hash(), tip.block_hash.into());
+    assert_eq!(block1.hash(), tip.block_hash.pack());
     assert_eq!(
         2, // cellbase1, tx10
         indexer_handle
@@ -246,7 +244,7 @@ async fn with_custom_block_filter() {
     indexer.rollback().await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
     assert_eq!(0, tip.block_number.value());
-    assert_eq!(block0.hash(), tip.block_hash.into());
+    assert_eq!(block0.hash(), tip.block_hash.pack());
     assert_eq!(
         0,
         indexer_handle
@@ -297,27 +295,27 @@ async fn with_custom_cell_filter() {
     let indexer_handle = AsyncRichIndexerHandle::new(storage, None, usize::MAX);
 
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"lock_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"lock_script1".to_vec()).pack())
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script2".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script2".to_vec()).pack())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script1".to_vec()).pack())
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"type_script2".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"type_script2".to_vec()).pack())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -325,45 +323,45 @@ async fn with_custom_cell_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()))
+                .type_(Some(type_script1.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()))
+                .type_(Some(type_script2.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0).build())
+        .header(HeaderBuilder::default().number(0.pack()).build())
         .build();
     indexer.append(&block0).await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
     assert_eq!(0, tip.block_number.value());
-    assert_eq!(block0.hash(), tip.block_hash.into());
+    assert_eq!(block0.hash(), tip.block_hash.pack());
     assert_eq!(
         1, // cellbase1, tx00
         indexer_handle
@@ -404,35 +402,35 @@ async fn with_custom_cell_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx10 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1))
+                .type_(Some(type_script1).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx11 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script2)
-                .type_(Some(type_script2))
+                .type_(Some(type_script2).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let block1 = BlockBuilder::default()
@@ -441,13 +439,11 @@ async fn with_custom_cell_filter() {
         .transaction(tx11)
         .header(
             HeaderBuilder::default()
-                .number(1)
+                .number(1.pack())
                 .parent_hash(block0.hash())
-                .epoch(EpochNumberWithFraction::new(
-                    block0.number() + 1,
-                    block0.number(),
-                    1000,
-                ))
+                .epoch(
+                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).pack(),
+                )
                 .build(),
         )
         .build();
@@ -455,7 +451,7 @@ async fn with_custom_cell_filter() {
     indexer.append(&block1).await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
     assert_eq!(1, tip.block_number.value());
-    assert_eq!(block1.hash(), tip.block_hash.into());
+    assert_eq!(block1.hash(), tip.block_hash.pack());
     assert_eq!(
         1, // tx10
         indexer_handle
@@ -496,7 +492,7 @@ async fn with_custom_cell_filter() {
     indexer.rollback().await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
     assert_eq!(0, tip.block_number.value());
-    assert_eq!(block0.hash(), tip.block_hash.into());
+    assert_eq!(block0.hash(), tip.block_hash.pack());
     assert_eq!(
         1, // tx00
         indexer_handle
diff --git a/util/rich-indexer/src/tests/query.rs b/util/rich-indexer/src/tests/query.rs
index c67bc8d8be..8adcba4aeb 100644
--- a/util/rich-indexer/src/tests/query.rs
+++ b/util/rich-indexer/src/tests/query.rs
@@ -44,11 +44,15 @@ async fn get_cells() {
     insert_blocks(pool.clone()).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(hex::decode("62e907b15cbf27d5425399ebf6f0fb50ebb88f18").expect("Decoding failed"))
+        .code_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(
+            hex::decode("62e907b15cbf27d5425399ebf6f0fb50ebb88f18")
+                .expect("Decoding failed")
+                .pack(),
+        )
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.into(),
@@ -65,11 +69,11 @@ async fn get_cells() {
     assert_eq!(cells.objects.len(), 1);
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(hex::decode("62e907b15cbf").expect("Decoding failed"))
+        .code_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(hex::decode("62e907b15cbf").expect("Decoding failed").pack())
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.into(),
@@ -93,7 +97,7 @@ async fn get_cells() {
             search_key,
             IndexerOrder::Asc,
             100u32.into(),
-            Some(Into::<packed::Bytes>::into([5u8, 0, 0, 0, 0, 0, 0, 0]).into()),
+            Some([5u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
         )
         .await
         .unwrap();
@@ -112,20 +116,22 @@ async fn get_cells() {
     assert_eq!(cell.output_data, None);
 
     let type_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x00000000000000000000000000000000000000000000000000545950455f4944"
-        ))
-        .hash_type(ScriptHashType::Type as u8)
+        .code_hash(
+            h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").pack(),
+        )
+        .hash_type((ScriptHashType::Type as u8).into())
         .args(
-            h256!("0xb2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626").as_bytes(),
+            h256!("0xb2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626")
+                .as_bytes()
+                .pack(),
         )
         .build();
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(vec![].as_slice())
+        .code_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(vec![].as_slice().pack())
         .build();
     let lock_script_len = extract_raw_data(&lock_script).len() as u64;
     let search_key = IndexerSearchKey {
@@ -150,7 +156,7 @@ async fn get_cells() {
             search_key,
             IndexerOrder::Asc,
             10u32.into(),
-            Some(Into::<packed::Bytes>::into([1u8, 0, 0, 0, 0, 0, 0, 0]).into()),
+            Some([1u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
         )
         .await
         .unwrap();
@@ -168,13 +174,14 @@ async fn get_cells_filter_data() {
 
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
-            .code_hash(h256!(
-                "0x00000000000000000000000000000000000000000000000000545950455f4944"
-            ))
-            .hash_type(ScriptHashType::Type as u8)
+            .code_hash(
+                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").pack(),
+            )
+            .hash_type((ScriptHashType::Type as u8).into())
             .args(
                 hex::decode("b2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626")
-                    .expect("Decoding failed"),
+                    .expect("Decoding failed")
+                    .pack(),
             )
             .build()
             .into(),
@@ -194,7 +201,7 @@ async fn get_cells_filter_data() {
             search_key,
             IndexerOrder::Asc,
             100u32.into(),
-            Some(Into::<packed::Bytes>::into([2u8, 0, 0, 0, 0, 0, 0, 0]).into()),
+            Some([2u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
         )
         .await
         .unwrap();
@@ -222,11 +229,11 @@ async fn get_cells_by_cursor() {
     insert_blocks(pool.clone()).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(hex::decode("").expect("Decoding failed"))
+        .code_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(hex::decode("").expect("Decoding failed").pack())
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.clone().into(),
@@ -241,7 +248,7 @@ async fn get_cells_by_cursor() {
             search_key,
             IndexerOrder::Asc,
             3u32.into(),
-            Some(Into::<packed::Bytes>::into([0u8, 0, 0, 0, 0, 0, 0, 0]).into()),
+            Some([0u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
         )
         .await
         .unwrap();
@@ -282,11 +289,11 @@ async fn get_transactions_ungrouped() {
     insert_blocks(pool).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(hex::decode("").expect("Decoding failed"))
+        .code_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(hex::decode("").expect("Decoding failed").pack())
         .build();
 
     let search_key = IndexerSearchKey {
@@ -340,11 +347,15 @@ async fn get_transactions_ungrouped() {
     assert_eq!(7, txs.objects.len());
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x709f3fda12f561cfacf92273c57a98fede188a3f1a59b1f888d113f9cce08649"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(hex::decode("b73961e46d9eb118d3de1d1e8f30b3af7bbf3160").expect("Decoding failed"))
+        .code_hash(
+            h256!("0x709f3fda12f561cfacf92273c57a98fede188a3f1a59b1f888d113f9cce08649").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(
+            hex::decode("b73961e46d9eb118d3de1d1e8f30b3af7bbf3160")
+                .expect("Decoding failed")
+                .pack(),
+        )
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.clone().into(),
@@ -402,11 +413,11 @@ async fn get_transactions_grouped() {
     insert_blocks(pool).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(h256!(
-            "0x0000000000000000000000000000000000000000000000000000000000000000"
-        ))
-        .hash_type(ScriptHashType::Data as u8)
-        .args(hex::decode("").expect("Decoding failed"))
+        .code_hash(
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+        )
+        .hash_type((ScriptHashType::Data as u8).into())
+        .args(hex::decode("").expect("Decoding failed").pack())
         .build();
 
     let search_key = IndexerSearchKey {
@@ -484,11 +495,15 @@ async fn get_cells_capacity() {
 
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
-            .code_hash(h256!(
-                "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
-            ))
-            .hash_type(ScriptHashType::Type as u8)
-            .args(hex::decode("57ccb07be6875f61d93636b0ee11b675494627d2").expect("Decoding failed"))
+            .code_hash(
+                h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8").pack(),
+            )
+            .hash_type((ScriptHashType::Type as u8).into())
+            .args(
+                hex::decode("57ccb07be6875f61d93636b0ee11b675494627d2")
+                    .expect("Decoding failed")
+                    .pack(),
+            )
             .build()
             .into(),
         script_type: IndexerScriptType::Lock,
@@ -511,13 +526,14 @@ async fn get_cells_capacity() {
 
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
-            .code_hash(h256!(
-                "0x00000000000000000000000000000000000000000000000000545950455f4944"
-            ))
-            .hash_type(ScriptHashType::Type as u8)
+            .code_hash(
+                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").pack(),
+            )
+            .hash_type((ScriptHashType::Type as u8).into())
             .args(
                 hex::decode("500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bc")
-                    .expect("Decoding failed"),
+                    .expect("Decoding failed")
+                    .pack(),
             )
             .build()
             .into(),
@@ -548,27 +564,27 @@ async fn rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"lock_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"lock_script1".to_vec()).pack())
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script2".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script2".to_vec()).pack())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script1".to_vec()).pack())
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"type_script2".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"type_script2".to_vec()).pack())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -576,40 +592,40 @@ async fn rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()))
+                .type_(Some(type_script1.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()))
+                .type_(Some(type_script2.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0).build())
+        .header(HeaderBuilder::default().number(0.pack()).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
@@ -622,35 +638,35 @@ async fn rpc() {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Bytes::from(i.to_string()))
+            .output_data(Bytes::from(i.to_string()).pack())
             .build();
 
         pre_tx0 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         pre_tx1 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()))
+                    .type_(Some(type_script2.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         pre_block = BlockBuilder::default()
@@ -659,13 +675,16 @@ async fn rpc() {
             .transaction(pre_tx1.clone())
             .header(
                 HeaderBuilder::default()
-                    .number(pre_block.number() + 1)
+                    .number((pre_block.number() + 1).pack())
                     .parent_hash(pre_block.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        pre_block.number() + 1,
-                        pre_block.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        )
+                        .pack(),
+                    )
                     .build(),
             )
             .build();
@@ -675,7 +694,7 @@ async fn rpc() {
 
     // test get_tip rpc
     let tip = rpc.get_indexer_tip().await.unwrap().unwrap();
-    assert_eq!(Into::<H256>::into(&pre_block.hash()), tip.block_hash);
+    assert_eq!(Unpack::<H256>::unpack(&pre_block.hash()), tip.block_hash);
     assert_eq!(pre_block.number(), tip.block_number.value());
 
     // test get_cells rpc
@@ -1088,12 +1107,12 @@ async fn rpc() {
         .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1))
+                .type_(Some(type_script1).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
     pool.write().unwrap().new_transaction(&pool_tx);
 
@@ -1153,27 +1172,27 @@ async fn script_search_mode_rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script1".to_vec()).pack())
         .build();
 
     let lock_script11 = ScriptBuilder::default()
         .code_hash(lock_script1.code_hash())
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script11".to_vec()))
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script11".to_vec()).pack())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script1".to_vec()).pack())
         .build();
 
     let type_script11 = ScriptBuilder::default()
         .code_hash(type_script1.code_hash())
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script11".to_vec()))
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script11".to_vec()).pack())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -1181,40 +1200,40 @@ async fn script_search_mode_rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()))
+                .type_(Some(type_script1.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script11.clone())
-                .type_(Some(type_script11.clone()))
+                .type_(Some(type_script11.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0).build())
+        .header(HeaderBuilder::default().number(0.pack()).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
@@ -1227,35 +1246,35 @@ async fn script_search_mode_rpc() {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Bytes::from(i.to_string()))
+            .output_data(Bytes::from(i.to_string()).pack())
             .build();
 
         pre_tx0 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000))
+                    .capacity(capacity_bytes!(1000).pack())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()))
+                    .type_(Some(type_script1.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         pre_tx1 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000))
+                    .capacity(capacity_bytes!(2000).pack())
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11.clone()))
+                    .type_(Some(type_script11.clone()).pack())
                     .build(),
             )
-            .output_data(packed::Bytes::default())
+            .output_data(Default::default())
             .build();
 
         pre_block = BlockBuilder::default()
@@ -1264,13 +1283,16 @@ async fn script_search_mode_rpc() {
             .transaction(pre_tx1.clone())
             .header(
                 HeaderBuilder::default()
-                    .number(pre_block.number() + 1)
+                    .number((pre_block.number() + 1).pack())
                     .parent_hash(pre_block.hash())
-                    .epoch(EpochNumberWithFraction::new(
-                        pre_block.number() + 1,
-                        pre_block.number(),
-                        1000,
-                    ))
+                    .epoch(
+                        EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        )
+                        .pack(),
+                    )
                     .build(),
             )
             .build();
@@ -1399,27 +1421,27 @@ async fn output_data_filter_mode_rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script1".to_vec()).pack())
         .build();
 
     let lock_script11 = ScriptBuilder::default()
         .code_hash(lock_script1.code_hash())
-        .hash_type(ScriptHashType::Type)
-        .args(Bytes::from(b"lock_script11".to_vec()))
+        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(b"lock_script11".to_vec()).pack())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()))
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script1".to_vec()))
+        .code_hash(H256(rand::random()).pack())
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script1".to_vec()).pack())
         .build();
 
     let type_script11 = ScriptBuilder::default()
         .code_hash(type_script1.code_hash())
-        .hash_type(ScriptHashType::Data)
-        .args(Bytes::from(b"type_script11".to_vec()))
+        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(b"type_script11".to_vec()).pack())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -1427,40 +1449,40 @@ async fn output_data_filter_mode_rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000))
+                .capacity(capacity_bytes!(1000).pack())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()))
+                .type_(Some(type_script1.clone()).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000))
+                .capacity(capacity_bytes!(2000).pack())
                 .lock(lock_script11.clone())
-                .type_(Some(type_script11.clone()))
+                .type_(Some(type_script11.clone()).pack())
                 .build(),
         )
-        .output_data(hex::decode("62e907b15cbf00aa00bbcc").unwrap())
+        .output_data(hex::decode("62e907b15cbf00aa00bbcc").unwrap().pack())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0).build())
+        .header(HeaderBuilder::default().number(0.pack()).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
diff --git a/util/test-chain-utils/src/chain.rs b/util/test-chain-utils/src/chain.rs
index 9347ffce00..7669089979 100644
--- a/util/test-chain-utils/src/chain.rs
+++ b/util/test-chain-utils/src/chain.rs
@@ -28,11 +28,11 @@ fn load_cell_from_path(path: &str) -> (CellOutput, Bytes, Script) {
     let data: Bytes = buffer.into();
 
     let cell = CellOutput::new_builder()
-        .capacity(Capacity::bytes(data.len()).unwrap())
+        .capacity(Capacity::bytes(data.len()).unwrap().pack())
         .build();
 
     let script = Script::new_builder()
-        .hash_type(ScriptHashType::Data)
+        .hash_type(ScriptHashType::Data.into())
         .code_hash(CellOutput::calc_data_hash(&data))
         .build();
 
@@ -134,13 +134,13 @@ pub fn always_success_consensus() -> Consensus {
     let always_success_tx = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::null(), 0))
         .output(always_success_cell.clone())
-        .output_data(always_success_cell_data)
+        .output_data(always_success_cell_data.pack())
         .witness(always_success_script.clone().into_witness())
         .build();
     let dao = genesis_dao_data(vec![&always_success_tx]).unwrap();
     let genesis = BlockBuilder::default()
-        .timestamp(GENESIS_TIMESTAMP)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)))
+        .timestamp(GENESIS_TIMESTAMP.pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
         .dao(dao)
         .transaction(always_success_tx)
         .build();
@@ -169,11 +169,11 @@ pub fn always_success_cellbase(
         builder.build()
     } else {
         let output = CellOutput::new_builder()
-            .capacity(reward)
+            .capacity(reward.pack())
             .lock(always_success_script.to_owned())
             .build();
 
-        builder.output(output).output_data(data).build()
+        builder.output(output).output_data(data.pack()).build()
     }
 }
 
@@ -203,7 +203,7 @@ pub fn ckb_testnet_consensus() -> Consensus {
 pub fn type_lock_script_code_hash() -> H256 {
     build_genesis_type_id_script(OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL)
         .calc_script_hash()
-        .into()
+        .unpack()
 }
 
 /// Return cell output and data in genesis block's cellbase transaction with index of SECP256K1/blake160 script,
diff --git a/util/test-chain-utils/src/median_time.rs b/util/test-chain-utils/src/median_time.rs
index 95f625322f..fe90aaee07 100644
--- a/util/test-chain-utils/src/median_time.rs
+++ b/util/test-chain-utils/src/median_time.rs
@@ -2,6 +2,7 @@ use ckb_traits::{HeaderFields, HeaderFieldsProvider};
 use ckb_types::{
     core::{BlockNumber, EpochNumberWithFraction, HeaderBuilder, HeaderView, TransactionInfo},
     packed::Byte32,
+    prelude::*,
 };
 use ckb_util::LinkedHashMap;
 use std::sync::Arc;
@@ -48,13 +49,16 @@ impl MockMedianTime {
                     .map(|(idx, timestamp)| {
                         let number = idx as BlockNumber;
                         let header = HeaderBuilder::default()
-                            .timestamp(timestamp)
-                            .number(number)
-                            .epoch(EpochNumberWithFraction::new(
-                                number % MOCK_EPOCH_LENGTH,
-                                number / MOCK_EPOCH_LENGTH,
-                                MOCK_EPOCH_LENGTH,
-                            ))
+                            .timestamp(timestamp.pack())
+                            .number(number.pack())
+                            .epoch(
+                                EpochNumberWithFraction::new(
+                                    number % MOCK_EPOCH_LENGTH,
+                                    number / MOCK_EPOCH_LENGTH,
+                                    MOCK_EPOCH_LENGTH,
+                                )
+                                .pack(),
+                            )
                             .parent_hash(parent_hash.clone())
                             .build();
                         parent_hash = header.hash();
diff --git a/util/test-chain-utils/src/mock_chain.rs b/util/test-chain-utils/src/mock_chain.rs
index 874c09a96b..059d3b3729 100644
--- a/util/test-chain-utils/src/mock_chain.rs
+++ b/util/test-chain-utils/src/mock_chain.rs
@@ -6,6 +6,7 @@ use crate::MockStore;
 use ckb_chain_spec::consensus::Consensus;
 use ckb_store::ChainStore;
 use ckb_types::core::{BlockBuilder, BlockView, HeaderView, TransactionView};
+use ckb_types::prelude::Pack;
 use ckb_types::utilities::difficulty_to_compact;
 use ckb_types::{packed, U256};
 
@@ -49,9 +50,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .compact_target(epoch.compact_target())
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .number((parent.number() + 1).pack())
+            .compact_target(epoch.compact_target().pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
             .dao(dao)
             .transaction(cellbase)
             .proposals(txs.iter().map(TransactionView::proposal_short_id))
@@ -78,9 +79,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
-            .compact_target(difficulty_to_compact(U256::from(difficulty)))
+            .number((parent.number() + 1).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .compact_target(difficulty_to_compact(U256::from(difficulty)).pack())
             .dao(dao)
             .transaction(cellbase)
             .proposals(ids)
@@ -102,9 +103,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
-            .compact_target(difficulty_to_compact(U256::from(difficulty)))
+            .number((parent.number() + 1).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .compact_target(difficulty_to_compact(U256::from(difficulty)).pack())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -126,9 +127,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .compact_target(difficulty_to_compact(difficulty + U256::from(inc)))
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .number((parent.number() + 1).pack())
+            .compact_target(difficulty_to_compact(difficulty + U256::from(inc)).pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -149,10 +150,10 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .compact_target(epoch.compact_target())
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
-            .nonce(nonce)
+            .number((parent.number() + 1).pack())
+            .compact_target(epoch.compact_target().pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .nonce(nonce.pack())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -173,9 +174,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .compact_target(epoch.compact_target())
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .number((parent.number() + 1).pack())
+            .compact_target(epoch.compact_target().pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -209,9 +210,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number(parent.number() + 1)
-            .compact_target(epoch.compact_target())
-            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .number((parent.number() + 1).pack())
+            .compact_target(epoch.compact_target().pack())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
             .dao(dao)
             .transaction(cellbase)
             .transactions(txs)
diff --git a/util/test-chain-utils/src/mock_store.rs b/util/test-chain-utils/src/mock_store.rs
index 53e44a3f40..1686f7b453 100644
--- a/util/test-chain-utils/src/mock_store.rs
+++ b/util/test-chain-utils/src/mock_store.rs
@@ -9,6 +9,7 @@ use ckb_types::{
         BlockExt, BlockView, EpochExt, HeaderView,
     },
     packed::{Byte32, OutPoint},
+    prelude::*,
 };
 use std::sync::Arc;
 use tempfile::TempDir;
@@ -118,14 +119,14 @@ impl CellProvider for MockStore {
         match self.store().get_transaction(&out_point.tx_hash()) {
             Some((tx, _)) => tx
                 .outputs()
-                .get(out_point.index().into())
+                .get(out_point.index().unpack())
                 .map(|cell| {
                     let data = tx
                         .outputs_data()
-                        .get(out_point.index().into())
+                        .get(out_point.index().unpack())
                         .expect("output data");
 
-                    let cell_meta = CellMetaBuilder::from_cell_output(cell, data.into())
+                    let cell_meta = CellMetaBuilder::from_cell_output(cell, data.unpack())
                         .out_point(out_point.to_owned())
                         .build();
 
diff --git a/util/test-chain-utils/src/mock_utils.rs b/util/test-chain-utils/src/mock_utils.rs
index 123b868a02..2b55b03c07 100644
--- a/util/test-chain-utils/src/mock_utils.rs
+++ b/util/test-chain-utils/src/mock_utils.rs
@@ -25,7 +25,7 @@ pub fn create_always_success_tx() -> TransactionView {
         .witness(script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
         .output(always_success_cell.clone())
-        .output_data(always_success_cell_data)
+        .output_data(always_success_cell_data.pack())
         .build()
 }
 
@@ -36,7 +36,7 @@ pub fn create_load_input_data_hash_cell_tx() -> TransactionView {
         .witness(script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
         .output(load_input_data_hash_cell_cell.clone())
-        .output_data(load_input_data_hash_cell_data)
+        .output_data(load_input_data_hash_cell_data.pack())
         .build()
 }
 
@@ -47,7 +47,7 @@ pub fn create_load_input_one_byte_cell_tx() -> TransactionView {
         .witness(script.clone().into_witness())
         .input(CellInput::new(OutPoint::null(), 0))
         .output(load_input_one_byte_cell.clone())
-        .output_data(load_input_one_byte_cell_data)
+        .output_data(load_input_one_byte_cell_data.pack())
         .build()
 }
 
@@ -97,11 +97,11 @@ pub fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity)
+                    .capacity(capacity.pack())
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new())
+            .output_data(Bytes::new().pack())
             .build()
     }
 }
@@ -120,7 +120,7 @@ pub fn create_multi_outputs_transaction(
     let total_capacity = indices
         .iter()
         .map(|i| {
-            let capacity: Capacity = parent_outputs.get(*i).unwrap().capacity().into();
+            let capacity: Capacity = parent_outputs.get(*i).unwrap().capacity().unpack();
             capacity
         })
         .try_fold(Capacity::zero(), Capacity::safe_add)
@@ -139,13 +139,13 @@ pub fn create_multi_outputs_transaction(
             output_capacity
         };
         CellOutputBuilder::default()
-            .capacity(capacity)
+            .capacity(capacity.pack())
             .lock(always_success_script.clone())
             .build()
     });
 
     let outputs_data = (0..output_len)
-        .map(|_| (&data).into())
+        .map(|_| data.pack())
         .collect::<Vec<packed::Bytes>>();
 
     let parent_pts = parent.output_pts();
@@ -177,11 +177,11 @@ pub fn create_transaction_with_out_point(out_point: OutPoint, unique_data: u8) -
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(data)
+        .output_data(data.pack())
         .input(CellInput::new(out_point, 0))
         .cell_dep(
             CellDep::new_builder()
diff --git a/util/types/src/conversion/blockchain.rs b/util/types/src/conversion/blockchain.rs
index 846e86ee73..65b1e0cc72 100644
--- a/util/types/src/conversion/blockchain.rs
+++ b/util/types/src/conversion/blockchain.rs
@@ -6,28 +6,9 @@ impl Pack<packed::Uint64> for core::EpochNumberWithFraction {
     }
 }
 
-impl From<core::EpochNumberWithFraction> for packed::Uint64 {
-    fn from(value: core::EpochNumberWithFraction) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::EpochNumberWithFraction> for packed::Uint64 {
-    fn from(value: &core::EpochNumberWithFraction) -> Self {
-        value.full_value().into()
-    }
-}
-
 impl<'r> Unpack<core::EpochNumberWithFraction> for packed::Uint64Reader<'r> {
     fn unpack(&self) -> core::EpochNumberWithFraction {
         core::EpochNumberWithFraction::from_full_value_unchecked(self.unpack())
     }
 }
 impl_conversion_for_entity_unpack!(core::EpochNumberWithFraction, Uint64);
-
-impl<'r> From<packed::Uint64Reader<'r>> for core::EpochNumberWithFraction {
-    fn from(value: packed::Uint64Reader<'r>) -> core::EpochNumberWithFraction {
-        core::EpochNumberWithFraction::from_full_value_unchecked(value.into())
-    }
-}
-impl_conversion_for_entity_from!(core::EpochNumberWithFraction, Uint64);
diff --git a/util/types/src/conversion/storage.rs b/util/types/src/conversion/storage.rs
index 50178a6da8..fc7374d02b 100644
--- a/util/types/src/conversion/storage.rs
+++ b/util/types/src/conversion/storage.rs
@@ -9,21 +9,6 @@ impl Pack<packed::HeaderView> for core::HeaderView {
     }
 }
 
-impl From<core::HeaderView> for packed::HeaderView {
-    fn from(value: core::HeaderView) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::HeaderView> for packed::HeaderView {
-    fn from(value: &core::HeaderView) -> Self {
-        packed::HeaderView::new_builder()
-            .data(value.data())
-            .hash(value.hash())
-            .build()
-    }
-}
-
 impl<'r> Unpack<core::HeaderView> for packed::HeaderViewReader<'r> {
     fn unpack(&self) -> core::HeaderView {
         core::HeaderView {
@@ -34,16 +19,6 @@ impl<'r> Unpack<core::HeaderView> for packed::HeaderViewReader<'r> {
 }
 impl_conversion_for_entity_unpack!(core::HeaderView, HeaderView);
 
-impl<'r> From<packed::HeaderViewReader<'r>> for core::HeaderView {
-    fn from(value: packed::HeaderViewReader<'r>) -> core::HeaderView {
-        core::HeaderView {
-            data: value.data().to_entity(),
-            hash: value.hash().to_entity(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::HeaderView, HeaderView);
-
 impl Pack<packed::UncleBlockVecView> for core::UncleBlockVecView {
     fn pack(&self) -> packed::UncleBlockVecView {
         packed::UncleBlockVecView::new_builder()
@@ -53,21 +28,6 @@ impl Pack<packed::UncleBlockVecView> for core::UncleBlockVecView {
     }
 }
 
-impl From<core::UncleBlockVecView> for packed::UncleBlockVecView {
-    fn from(value: core::UncleBlockVecView) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::UncleBlockVecView> for packed::UncleBlockVecView {
-    fn from(value: &core::UncleBlockVecView) -> Self {
-        packed::UncleBlockVecView::new_builder()
-            .data(value.data())
-            .hashes(value.hashes())
-            .build()
-    }
-}
-
 impl<'r> Unpack<core::UncleBlockVecView> for packed::UncleBlockVecViewReader<'r> {
     fn unpack(&self) -> core::UncleBlockVecView {
         core::UncleBlockVecView {
@@ -78,16 +38,6 @@ impl<'r> Unpack<core::UncleBlockVecView> for packed::UncleBlockVecViewReader<'r>
 }
 impl_conversion_for_entity_unpack!(core::UncleBlockVecView, UncleBlockVecView);
 
-impl<'r> From<packed::UncleBlockVecViewReader<'r>> for core::UncleBlockVecView {
-    fn from(value: packed::UncleBlockVecViewReader<'r>) -> core::UncleBlockVecView {
-        core::UncleBlockVecView {
-            data: value.data().to_entity(),
-            hashes: value.hashes().to_entity(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::UncleBlockVecView, UncleBlockVecView);
-
 impl Pack<packed::TransactionView> for core::TransactionView {
     fn pack(&self) -> packed::TransactionView {
         packed::TransactionView::new_builder()
@@ -98,22 +48,6 @@ impl Pack<packed::TransactionView> for core::TransactionView {
     }
 }
 
-impl From<core::TransactionView> for packed::TransactionView {
-    fn from(value: core::TransactionView) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::TransactionView> for packed::TransactionView {
-    fn from(value: &core::TransactionView) -> Self {
-        packed::TransactionView::new_builder()
-            .data(value.data())
-            .hash(value.hash())
-            .witness_hash(value.witness_hash())
-            .build()
-    }
-}
-
 impl<'r> Unpack<core::TransactionView> for packed::TransactionViewReader<'r> {
     fn unpack(&self) -> core::TransactionView {
         core::TransactionView {
@@ -125,17 +59,6 @@ impl<'r> Unpack<core::TransactionView> for packed::TransactionViewReader<'r> {
 }
 impl_conversion_for_entity_unpack!(core::TransactionView, TransactionView);
 
-impl<'r> From<packed::TransactionViewReader<'r>> for core::TransactionView {
-    fn from(value: packed::TransactionViewReader<'r>) -> core::TransactionView {
-        core::TransactionView {
-            data: value.data().to_entity(),
-            hash: value.hash().to_entity(),
-            witness_hash: value.witness_hash().to_entity(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::TransactionView, TransactionView);
-
 impl<'r> Unpack<core::BlockExt> for packed::BlockExtReader<'r> {
     fn unpack(&self) -> core::BlockExt {
         core::BlockExt {
@@ -151,27 +74,12 @@ impl<'r> Unpack<core::BlockExt> for packed::BlockExtReader<'r> {
 }
 impl_conversion_for_entity_unpack!(core::BlockExt, BlockExt);
 
-impl<'r> From<packed::BlockExtReader<'r>> for core::BlockExt {
-    fn from(value: packed::BlockExtReader<'r>) -> core::BlockExt {
-        core::BlockExt {
-            received_at: value.received_at().into(),
-            total_difficulty: value.total_difficulty().into(),
-            total_uncles_count: value.total_uncles_count().into(),
-            verified: value.verified().into(),
-            txs_fees: value.txs_fees().into(),
-            cycles: None,
-            txs_sizes: None,
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::BlockExt, BlockExt);
-
 impl Pack<packed::BlockExtV1> for core::BlockExt {
     fn pack(&self) -> packed::BlockExtV1 {
         packed::BlockExtV1::new_builder()
-            .received_at(self.received_at)
+            .received_at(self.received_at.pack())
             .total_difficulty(self.total_difficulty.pack())
-            .total_uncles_count(self.total_uncles_count)
+            .total_uncles_count(self.total_uncles_count.pack())
             .verified(self.verified.pack())
             .txs_fees((self.txs_fees[..]).pack())
             .cycles(self.cycles.pack())
@@ -180,26 +88,6 @@ impl Pack<packed::BlockExtV1> for core::BlockExt {
     }
 }
 
-impl From<core::BlockExt> for packed::BlockExtV1 {
-    fn from(value: core::BlockExt) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::BlockExt> for packed::BlockExtV1 {
-    fn from(value: &core::BlockExt) -> Self {
-        packed::BlockExtV1::new_builder()
-            .received_at(value.received_at)
-            .total_difficulty(&value.total_difficulty)
-            .total_uncles_count(value.total_uncles_count)
-            .verified(value.verified)
-            .txs_fees(&value.txs_fees[..])
-            .cycles(&value.cycles)
-            .txs_sizes(&value.txs_sizes)
-            .build()
-    }
-}
-
 impl<'r> Unpack<core::BlockExt> for packed::BlockExtV1Reader<'r> {
     fn unpack(&self) -> core::BlockExt {
         core::BlockExt {
@@ -215,53 +103,17 @@ impl<'r> Unpack<core::BlockExt> for packed::BlockExtV1Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(core::BlockExt, BlockExtV1);
 
-impl<'r> From<packed::BlockExtV1Reader<'r>> for core::BlockExt {
-    fn from(value: packed::BlockExtV1Reader<'r>) -> core::BlockExt {
-        core::BlockExt {
-            received_at: value.received_at().into(),
-            total_difficulty: value.total_difficulty().into(),
-            total_uncles_count: value.total_uncles_count().into(),
-            verified: value.verified().into(),
-            txs_fees: value.txs_fees().into(),
-            cycles: value.cycles().into(),
-            txs_sizes: value.txs_sizes().into(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::BlockExt, BlockExtV1);
-
 impl Pack<packed::EpochExt> for core::EpochExt {
     fn pack(&self) -> packed::EpochExt {
         packed::EpochExt::new_builder()
-            .number(self.number())
+            .number(self.number().pack())
             .base_block_reward(self.base_block_reward().pack())
             .remainder_reward(self.remainder_reward().pack())
             .previous_epoch_hash_rate(self.previous_epoch_hash_rate().pack())
             .last_block_hash_in_previous_epoch(self.last_block_hash_in_previous_epoch())
-            .start_number(self.start_number())
-            .length(self.length())
-            .compact_target(self.compact_target())
-            .build()
-    }
-}
-
-impl From<core::EpochExt> for packed::EpochExt {
-    fn from(value: core::EpochExt) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::EpochExt> for packed::EpochExt {
-    fn from(value: &core::EpochExt) -> Self {
-        packed::EpochExt::new_builder()
-            .number(value.number())
-            .base_block_reward(value.base_block_reward())
-            .remainder_reward(value.remainder_reward())
-            .previous_epoch_hash_rate(value.previous_epoch_hash_rate())
-            .last_block_hash_in_previous_epoch(value.last_block_hash_in_previous_epoch())
-            .start_number(value.start_number())
-            .length(value.length())
-            .compact_target(value.compact_target())
+            .start_number(self.start_number().pack())
+            .length(self.length().pack())
+            .compact_target(self.compact_target().pack())
             .build()
     }
 }
@@ -282,58 +134,20 @@ impl<'r> Unpack<core::EpochExt> for packed::EpochExtReader<'r> {
 }
 impl_conversion_for_entity_unpack!(core::EpochExt, EpochExt);
 
-impl<'r> From<packed::EpochExtReader<'r>> for core::EpochExt {
-    fn from(value: packed::EpochExtReader<'r>) -> core::EpochExt {
-        core::EpochExt {
-            number: value.number().into(),
-            base_block_reward: value.base_block_reward().into(),
-            remainder_reward: value.remainder_reward().into(),
-            previous_epoch_hash_rate: value.previous_epoch_hash_rate().into(),
-            last_block_hash_in_previous_epoch: value
-                .last_block_hash_in_previous_epoch()
-                .to_entity(),
-            start_number: value.start_number().into(),
-            length: value.length().into(),
-            compact_target: value.compact_target().into(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::EpochExt, EpochExt);
-
 impl Pack<packed::TransactionInfo> for core::TransactionInfo {
     fn pack(&self) -> packed::TransactionInfo {
         let key = packed::TransactionKey::new_builder()
             .block_hash(self.block_hash.clone())
-            .index(self.index)
+            .index(self.index.pack())
             .build();
         packed::TransactionInfo::new_builder()
             .key(key)
-            .block_number(self.block_number)
+            .block_number(self.block_number.pack())
             .block_epoch(self.block_epoch.pack())
             .build()
     }
 }
 
-impl From<core::TransactionInfo> for packed::TransactionInfo {
-    fn from(value: core::TransactionInfo) -> Self {
-        (&value).into()
-    }
-}
-
-impl From<&core::TransactionInfo> for packed::TransactionInfo {
-    fn from(value: &core::TransactionInfo) -> Self {
-        let key = packed::TransactionKey::new_builder()
-            .block_hash(value.block_hash.clone())
-            .index(value.index)
-            .build();
-        packed::TransactionInfo::new_builder()
-            .key(key)
-            .block_number(value.block_number)
-            .block_epoch(value.block_epoch)
-            .build()
-    }
-}
-
 impl<'r> Unpack<core::TransactionInfo> for packed::TransactionInfoReader<'r> {
     fn unpack(&self) -> core::TransactionInfo {
         core::TransactionInfo {
@@ -345,15 +159,3 @@ impl<'r> Unpack<core::TransactionInfo> for packed::TransactionInfoReader<'r> {
     }
 }
 impl_conversion_for_entity_unpack!(core::TransactionInfo, TransactionInfo);
-
-impl<'r> From<packed::TransactionInfoReader<'r>> for core::TransactionInfo {
-    fn from(value: packed::TransactionInfoReader<'r>) -> core::TransactionInfo {
-        core::TransactionInfo {
-            block_hash: value.key().block_hash().to_entity(),
-            index: value.key().index().into(),
-            block_number: value.block_number().into(),
-            block_epoch: value.block_epoch().into(),
-        }
-    }
-}
-impl_conversion_for_entity_from!(core::TransactionInfo, TransactionInfo);
diff --git a/util/types/src/conversion/utilities.rs b/util/types/src/conversion/utilities.rs
index 3880e583fa..0fbdc5bd98 100644
--- a/util/types/src/conversion/utilities.rs
+++ b/util/types/src/conversion/utilities.rs
@@ -7,19 +7,3 @@ macro_rules! impl_conversion_for_entity_unpack {
         }
     };
 }
-
-macro_rules! impl_conversion_for_entity_from {
-    ($original:ty, $entity:ident) => {
-        impl From<packed::$entity> for $original {
-            fn from(value: packed::$entity) -> $original {
-                (&value).into()
-            }
-        }
-
-        impl From<&packed::$entity> for $original {
-            fn from(value: &packed::$entity) -> $original {
-                value.as_reader().into()
-            }
-        }
-    };
-}
diff --git a/util/types/src/core/advanced_builders.rs b/util/types/src/core/advanced_builders.rs
index 007fd57225..eae6b39a9e 100644
--- a/util/types/src/core/advanced_builders.rs
+++ b/util/types/src/core/advanced_builders.rs
@@ -1,7 +1,5 @@
 //! Advanced builders for Transaction(View), Header(View) and Block(View).
 
-use ckb_gen_types::packed::{ProposalShortIdVec, UncleBlockVec};
-
 use crate::{
     constants, core, packed,
     prelude::*,
@@ -75,7 +73,7 @@ pub struct BlockBuilder {
 impl ::std::default::Default for TransactionBuilder {
     fn default() -> Self {
         Self {
-            version: constants::TX_VERSION.into(),
+            version: constants::TX_VERSION.pack(),
             cell_deps: Default::default(),
             header_deps: Default::default(),
             inputs: Default::default(),
@@ -89,15 +87,15 @@ impl ::std::default::Default for TransactionBuilder {
 impl ::std::default::Default for HeaderBuilder {
     fn default() -> Self {
         Self {
-            version: constants::BLOCK_VERSION.into(),
+            version: constants::BLOCK_VERSION.pack(),
             parent_hash: Default::default(),
             timestamp: Default::default(),
             number: Default::default(),
             transactions_root: Default::default(),
             proposals_hash: Default::default(),
-            compact_target: DIFF_TWO.into(),
+            compact_target: DIFF_TWO.pack(),
             extra_hash: Default::default(),
-            epoch: core::EpochNumberWithFraction::new_unchecked(0, 0, 0).into(),
+            epoch: core::EpochNumberWithFraction::new_unchecked(0, 0, 0).pack(),
             dao: Default::default(),
             nonce: Default::default(),
         }
@@ -111,21 +109,15 @@ impl ::std::default::Default for HeaderBuilder {
 macro_rules! def_setter_simple {
     (__add_doc, $prefix:ident, $field:ident, $type:ident, $comment:expr) => {
         #[doc = $comment]
-        pub fn $field<T>(mut self, v: T) -> Self
-        where
-            T: ::core::convert::Into<packed::$type>,
-        {
-            self.$prefix.$field = v.into();
+        pub fn $field(mut self, v: packed::$type) -> Self {
+            self.$prefix.$field = v;
             self
         }
     };
     (__add_doc, $field:ident, $type:ident, $comment:expr) => {
         #[doc = $comment]
-        pub fn $field<T>(mut self, v: T) -> Self
-        where
-            T: ::core::convert::Into<packed::$type>,
-        {
-            self.$field = v.into();
+        pub fn $field(mut self, v: packed::$type) -> Self {
+            self.$field = v;
             self
         }
     };
@@ -155,11 +147,8 @@ macro_rules! def_setter_for_vector {
         $comment_push:expr, $comment_extend:expr, $comment_set:expr,
     ) => {
         #[doc = $comment_push]
-        pub fn $func_push<T>(mut self, v: T) -> Self
-        where
-            T: ::core::convert::Into<$prefix::$type>,
-        {
-            self.$field.push(v.into());
+        pub fn $func_push(mut self, v: $prefix::$type) -> Self {
+            self.$field.push(v);
             self
         }
         #[doc = $comment_extend]
@@ -238,15 +227,15 @@ impl TransactionBuilder {
         } = self;
         let raw = packed::RawTransaction::new_builder()
             .version(version)
-            .cell_deps(cell_deps)
-            .header_deps(header_deps)
-            .inputs(inputs)
-            .outputs(outputs)
-            .outputs_data(outputs_data)
+            .cell_deps(cell_deps.pack())
+            .header_deps(header_deps.pack())
+            .inputs(inputs.pack())
+            .outputs(outputs.pack())
+            .outputs_data(outputs_data.pack())
             .build();
         let tx = packed::Transaction::new_builder()
             .raw(raw)
-            .witnesses(witnesses)
+            .witnesses(witnesses.pack())
             .build();
         let hash = tx.calc_tx_hash();
         let witness_hash = tx.calc_witness_hash();
@@ -287,12 +276,12 @@ impl HeaderBuilder {
             nonce,
         } = self;
         debug_assert!(
-            Into::<u32>::into(&compact_target) > 0,
+            Unpack::<u32>::unpack(&compact_target) > 0,
             "[HeaderBuilder] compact_target should greater than zero"
         );
         debug_assert!(
-            Into::<core::BlockNumber>::into(&number) == 0
-                || Into::<core::EpochNumberWithFraction>::into(&epoch).is_well_formed(),
+            Unpack::<core::BlockNumber>::unpack(&number) == 0
+                || Unpack::<core::EpochNumberWithFraction>::unpack(&epoch).is_well_formed(),
             "[HeaderBuilder] epoch {epoch:x} should be well formed, \
             unless it's in the genesis block (number: {number:x})"
         );
@@ -408,8 +397,8 @@ impl BlockBuilder {
                 )
         };
 
-        let proposals: ProposalShortIdVec = proposals.into();
-        let uncles: UncleBlockVec = uncles.into();
+        let proposals = proposals.pack();
+        let uncles = uncles.pack();
 
         let core::HeaderView { data, hash } = if reset_header {
             let raw_transactions_root = merkle_root(&tx_hashes[..]);
@@ -434,7 +423,7 @@ impl BlockBuilder {
             packed::BlockV1::new_builder()
                 .header(data)
                 .uncles(uncles)
-                .transactions(transactions)
+                .transactions(transactions.pack())
                 .proposals(proposals)
                 .extension(extension)
                 .build()
@@ -443,14 +432,14 @@ impl BlockBuilder {
             packed::Block::new_builder()
                 .header(data)
                 .uncles(uncles)
-                .transactions(transactions)
+                .transactions(transactions.pack())
                 .proposals(proposals)
                 .build()
         };
         core::BlockView {
             data: block,
             hash,
-            uncle_hashes: uncle_hashes.into(),
+            uncle_hashes: uncle_hashes.pack(),
             tx_hashes,
             tx_witness_hashes,
         }
diff --git a/util/types/src/core/cell.rs b/util/types/src/core/cell.rs
index ec77abf34d..e5b62499ab 100644
--- a/util/types/src/core/cell.rs
+++ b/util/types/src/core/cell.rs
@@ -148,7 +148,7 @@ impl CellMeta {
 
     /// TODO(doc): @quake
     pub fn capacity(&self) -> Capacity {
-        self.cell_output.capacity().into()
+        self.cell_output.capacity().unpack()
     }
 
     /// TODO(doc): @quake
@@ -339,7 +339,7 @@ impl ResolvedTransaction {
             for cell_meta in &self.resolved_dep_groups {
                 let cell_dep = CellDep::new_builder()
                     .out_point(cell_meta.out_point.clone())
-                    .dep_type(DepType::DepGroup)
+                    .dep_type(DepType::DepGroup.into())
                     .build();
 
                 let dep_group = system_cell.get(&cell_dep);
@@ -353,7 +353,7 @@ impl ResolvedTransaction {
             for cell_meta in &self.resolved_cell_deps {
                 let cell_dep = CellDep::new_builder()
                     .out_point(cell_meta.out_point.clone())
-                    .dep_type(DepType::Code)
+                    .dep_type(DepType::Code.into())
                     .build();
 
                 if system_cell.get(&cell_dep).is_none()
@@ -508,7 +508,7 @@ impl<'a> CellProvider for BlockCellProvider<'a> {
             .get(&out_point.tx_hash())
             .and_then(|i| {
                 let transaction = self.block.transaction(*i).should_be_ok();
-                let j: usize = out_point.index().into();
+                let j: usize = out_point.index().unpack();
                 self.block.output(*i, j).map(|output| {
                     let data = transaction
                         .outputs_data()
@@ -559,7 +559,7 @@ impl CellChecker for TransactionsChecker {
     fn is_live(&self, out_point: &OutPoint) -> Option<bool> {
         self.inner
             .get(&out_point.tx_hash())
-            .and_then(|outputs| outputs.get(out_point.index().into()).map(|_| true))
+            .and_then(|outputs| outputs.get(out_point.index().unpack()).map(|_| true))
     }
 }
 
@@ -587,11 +587,11 @@ impl<'a> CellProvider for TransactionsProvider<'a> {
         match self.transactions.get(&out_point.tx_hash()) {
             Some(tx) => tx
                 .outputs()
-                .get(out_point.index().into())
+                .get(out_point.index().unpack())
                 .map(|cell| {
                     let data = tx
                         .outputs_data()
-                        .get(out_point.index().into())
+                        .get(out_point.index().unpack())
                         .expect("output data")
                         .raw_data();
                     let cell_meta = CellMetaBuilder::from_cell_output(cell, data)
@@ -853,27 +853,27 @@ pub fn setup_system_cell_cache<CP: CellProvider>(
     let secp_cell_transaction = &genesis.transactions()[1];
     let secp_code_dep = CellDep::new_builder()
         .out_point(OutPoint::new(system_cell_transaction.hash(), 1))
-        .dep_type(DepType::Code)
+        .dep_type(DepType::Code.into())
         .build();
 
     let dao_dep = CellDep::new_builder()
         .out_point(OutPoint::new(system_cell_transaction.hash(), 2))
-        .dep_type(DepType::Code)
+        .dep_type(DepType::Code.into())
         .build();
 
     let secp_data_dep = CellDep::new_builder()
         .out_point(OutPoint::new(system_cell_transaction.hash(), 3))
-        .dep_type(DepType::Code)
+        .dep_type(DepType::Code.into())
         .build();
 
     let secp_group_dep = CellDep::new_builder()
         .out_point(OutPoint::new(secp_cell_transaction.hash(), 0))
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
 
     let multi_sign_secp_group = CellDep::new_builder()
         .out_point(OutPoint::new(secp_cell_transaction.hash(), 1))
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
 
     let mut cell_deps = HashMap::new();
diff --git a/util/types/src/core/extras.rs b/util/types/src/core/extras.rs
index d02e4a8bb9..a7261a2fb5 100644
--- a/util/types/src/core/extras.rs
+++ b/util/types/src/core/extras.rs
@@ -60,7 +60,7 @@ impl TransactionInfo {
     pub fn key(&self) -> packed::TransactionKey {
         packed::TransactionKey::new_builder()
             .block_hash(self.block_hash.clone())
-            .index(self.index)
+            .index(self.index.pack())
             .build()
     }
 
diff --git a/util/types/src/core/tests/cell.rs b/util/types/src/core/tests/cell.rs
index cb17b78bab..28de967f24 100644
--- a/util/types/src/core/tests/cell.rs
+++ b/util/types/src/core/tests/cell.rs
@@ -14,7 +14,7 @@ use crate::{
         TransactionInfo, TransactionView,
     },
     h256,
-    packed::{self, Byte32, CellDep, CellInput, CellOutput, OutPoint},
+    packed::{Byte32, CellDep, CellInput, CellOutput, OutPoint},
     prelude::*,
 };
 
@@ -57,7 +57,7 @@ impl CellProvider for CellMemoryDb {
 
 fn generate_dummy_cell_meta_with_info(out_point: OutPoint, data: Bytes) -> CellMeta {
     let cell_output = CellOutput::new_builder()
-        .capacity(capacity_bytes!(2))
+        .capacity(capacity_bytes!(2).pack())
         .build();
     let data_hash = CellOutput::calc_data_hash(&data);
     CellMeta {
@@ -114,9 +114,9 @@ fn resolve_transaction_should_resolve_dep_group() {
     let header_checker = BlockHeadersChecker::default();
 
     let op_dep = OutPoint::new(Byte32::zero(), 72);
-    let op_1 = OutPoint::new(h256!("0x13").into(), 1);
-    let op_2 = OutPoint::new(h256!("0x23").into(), 2);
-    let op_3 = OutPoint::new(h256!("0x33").into(), 3);
+    let op_1 = OutPoint::new(h256!("0x13").pack(), 1);
+    let op_2 = OutPoint::new(h256!("0x23").pack(), 2);
+    let op_3 = OutPoint::new(h256!("0x33").pack(), 3);
 
     for op in &[&op_1, &op_2, &op_3] {
         cell_provider.cells.insert(
@@ -124,9 +124,9 @@ fn resolve_transaction_should_resolve_dep_group() {
             Some(generate_dummy_cell_meta_with_out_point((*op).clone())),
         );
     }
-    let cell_data =
-        Into::<packed::OutPointVec>::into(vec![op_1.clone(), op_2.clone(), op_3.clone()])
-            .as_bytes();
+    let cell_data = vec![op_1.clone(), op_2.clone(), op_3.clone()]
+        .pack()
+        .as_bytes();
     let dep_group_cell = generate_dummy_cell_meta_with_data(cell_data);
     cell_provider
         .cells
@@ -134,7 +134,7 @@ fn resolve_transaction_should_resolve_dep_group() {
 
     let dep = CellDep::new_builder()
         .out_point(op_dep)
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
 
     let transaction = TransactionBuilder::default().cell_dep(dep).build();
@@ -167,7 +167,7 @@ fn resolve_transaction_resolve_dep_group_failed_because_invalid_data() {
 
     let dep = CellDep::new_builder()
         .out_point(op_dep.clone())
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
 
     let transaction = TransactionBuilder::default().cell_dep(dep).build();
@@ -186,9 +186,9 @@ fn resolve_transaction_resolve_dep_group_failed_because_unknown_sub_cell() {
     let mut cell_provider = CellMemoryDb::default();
     let header_checker = BlockHeadersChecker::default();
 
-    let op_unknown = OutPoint::new(h256!("0x45").into(), 5);
+    let op_unknown = OutPoint::new(h256!("0x45").pack(), 5);
     let op_dep = OutPoint::new(Byte32::zero(), 72);
-    let cell_data = Into::<packed::OutPointVec>::into(vec![op_unknown.clone()]).as_bytes();
+    let cell_data = vec![op_unknown.clone()].pack().as_bytes();
     let dep_group_cell = generate_dummy_cell_meta_with_data(cell_data);
     cell_provider
         .cells
@@ -196,7 +196,7 @@ fn resolve_transaction_resolve_dep_group_failed_because_unknown_sub_cell() {
 
     let dep = CellDep::new_builder()
         .out_point(op_dep)
-        .dep_type(DepType::DepGroup)
+        .dep_type(DepType::DepGroup.into())
         .build();
 
     let transaction = TransactionBuilder::default().cell_dep(dep).build();
@@ -215,11 +215,11 @@ fn resolve_transaction_test_header_deps_all_ok() {
     let cell_provider = CellMemoryDb::default();
     let mut header_checker = BlockHeadersChecker::default();
 
-    let block_hash1 = h256!("0x1111");
-    let block_hash2 = h256!("0x2222");
+    let block_hash1 = h256!("0x1111").pack();
+    let block_hash2 = h256!("0x2222").pack();
 
-    header_checker.push_attached(block_hash1.clone().into());
-    header_checker.push_attached(block_hash2.clone().into());
+    header_checker.push_attached(block_hash1.clone());
+    header_checker.push_attached(block_hash2.clone());
 
     let transaction = TransactionBuilder::default()
         .header_dep(block_hash1)
@@ -242,8 +242,8 @@ fn resolve_transaction_should_test_have_invalid_header_dep() {
     let cell_provider = CellMemoryDb::default();
     let mut header_checker = BlockHeadersChecker::default();
 
-    let main_chain_block_hash: Byte32 = h256!("0xaabbcc").into();
-    let invalid_block_hash: Byte32 = h256!("0x3344").into();
+    let main_chain_block_hash = h256!("0xaabbcc").pack();
+    let invalid_block_hash = h256!("0x3344").pack();
 
     header_checker.push_attached(main_chain_block_hash.clone());
 
@@ -268,16 +268,16 @@ fn resolve_transaction_should_test_have_invalid_header_dep() {
 
 #[test]
 fn resolve_transaction_should_reject_incorrect_order_txs() {
-    let out_point = OutPoint::new(h256!("0x2").into(), 3);
+    let out_point = OutPoint::new(h256!("0x2").pack(), 3);
 
     let tx1 = TransactionBuilder::default()
         .input(CellInput::new(out_point, 0))
         .output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(2))
+                .capacity(capacity_bytes!(2).pack())
                 .build(),
         )
-        .output_data(packed::Bytes::default())
+        .output_data(Default::default())
         .build();
 
     let tx2 = TransactionBuilder::default()
@@ -336,7 +336,7 @@ fn resolve_transaction_should_allow_dep_cell_in_current_tx_input() {
     let mut cell_provider = CellMemoryDb::default();
     let header_checker = BlockHeadersChecker::default();
 
-    let out_point = OutPoint::new(h256!("0x2").into(), 3);
+    let out_point = OutPoint::new(h256!("0x2").pack(), 3);
 
     let dummy_cell_meta = generate_dummy_cell_meta();
     cell_provider
@@ -360,7 +360,7 @@ fn resolve_transaction_should_reject_dep_cell_consumed_by_previous_input() {
     let mut cell_provider = CellMemoryDb::default();
     let header_checker = BlockHeadersChecker::default();
 
-    let out_point = OutPoint::new(h256!("0x2").into(), 3);
+    let out_point = OutPoint::new(h256!("0x2").pack(), 3);
 
     cell_provider
         .cells
diff --git a/util/types/src/core/tests/transaction_meta.rs b/util/types/src/core/tests/transaction_meta.rs
index 7729cbe4d6..6a0d666dc4 100644
--- a/util/types/src/core/tests/transaction_meta.rs
+++ b/util/types/src/core/tests/transaction_meta.rs
@@ -2,6 +2,7 @@ use crate::{
     core::{TransactionMeta, TransactionMetaBuilder},
     h256,
     packed::Byte32,
+    prelude::*,
 };
 
 #[test]
@@ -22,7 +23,7 @@ fn set_unset_dead_out_of_bounds() {
 fn test_transaction_meta_constructors() {
     let block_number = 10;
     let epoch_number = 10;
-    let block_hash: Byte32 = h256!("0xf").into();
+    let block_hash: Byte32 = h256!("0xf").pack();
     let outputs_count = 4;
     let mut meta1 =
         TransactionMeta::new_cellbase(block_number, epoch_number, block_hash, outputs_count, false);
diff --git a/util/types/src/core/tests/views.rs b/util/types/src/core/tests/views.rs
index ab00e1f600..d3c3aeb4de 100644
--- a/util/types/src/core/tests/views.rs
+++ b/util/types/src/core/tests/views.rs
@@ -21,13 +21,13 @@ fn test_block_view_convert_from_packed_block() {
 fn test_extension_field_in_block_view() {
     let block = {
         let uncle1 = packed::Block::new_advanced_builder()
-            .number(1u64)
-            .epoch(EpochNumberWithFraction::new(0, 1, 1000))
+            .number(1u64.pack())
+            .epoch(EpochNumberWithFraction::new(0, 1, 1000).pack())
             .build()
             .as_uncle();
         let uncle2 = packed::Block::new_advanced_builder()
-            .number(2u64)
-            .epoch(EpochNumberWithFraction::new(0, 2, 1000))
+            .number(2u64.pack())
+            .epoch(EpochNumberWithFraction::new(0, 2, 1000).pack())
             .build()
             .as_uncle();
         packed::Block::new_advanced_builder()
@@ -41,7 +41,7 @@ fn test_extension_field_in_block_view() {
         block.transactions(),
         block.data().proposals(),
     );
-    let extension: packed::Bytes = [0u8, 1, 2, 3, 4, 5, 6, 7].into();
+    let extension: packed::Bytes = [0u8, 1, 2, 3, 4, 5, 6, 7].pack();
     // block with extension but not reset all hashes
     let block2_v1_un = BlockView::new_unchecked_with_extension(
         block.header(),
diff --git a/util/types/src/core/views.rs b/util/types/src/core/views.rs
index 146e1107e7..326751b3eb 100644
--- a/util/types/src/core/views.rs
+++ b/util/types/src/core/views.rs
@@ -245,7 +245,7 @@ macro_rules! define_inner_getter {
         define_inner_getter!(
             $field,
             $type,
-            data().as_reader().raw().$field().into(),
+            data().as_reader().raw().$field().unpack(),
             concat!("Gets `raw.", stringify!($field), "`.")
         );
     };
@@ -261,7 +261,7 @@ macro_rules! define_inner_getter {
         define_inner_getter!(
             $field,
             $type,
-            data().as_reader().header().raw().$field().into(),
+            data().as_reader().header().raw().$field().unpack(),
             concat!("Gets `header.raw.", stringify!($field), "`.")
         );
     };
@@ -277,7 +277,7 @@ macro_rules! define_inner_getter {
         define_inner_getter!(
             $field,
             $type,
-            data().as_reader().header().raw().$field().into(),
+            data().as_reader().header().raw().$field().unpack(),
             concat!("Gets `header.raw.", stringify!($field), "`.")
         );
     };
@@ -304,7 +304,7 @@ impl TransactionView {
 
     /// Gets `raw.version`.
     pub fn version(&self) -> Version {
-        self.data().raw().version().into()
+        self.data().raw().version().unpack()
     }
 
     /// Gets `raw.cell_deps`.
@@ -440,7 +440,7 @@ impl ExtraHashView {
             blake2b.update(uncles_hash.as_slice());
             blake2b.update(extension_hash.as_slice());
             blake2b.finalize(&mut ret);
-            (extension_hash, ret.into())
+            (extension_hash, ret.pack())
         });
         Self {
             uncles_hash,
@@ -492,7 +492,7 @@ impl HeaderView {
 
     /// Gets `nonce`.
     pub fn nonce(&self) -> u128 {
-        self.data().nonce().into()
+        self.data().nonce().unpack()
     }
 
     /// Checks whether the header is the header block.
@@ -530,7 +530,7 @@ impl UncleBlockView {
 
     /// Gets `header.nonce`.
     pub fn nonce(&self) -> u128 {
-        self.data().header().nonce().into()
+        self.data().header().nonce().unpack()
     }
 
     /// Gets `header`.
@@ -637,7 +637,7 @@ impl BlockView {
 
     /// Gets `header.nonce`.
     pub fn nonce(&self) -> u128 {
-        self.data().header().nonce().into()
+        self.data().header().nonce().unpack()
     }
 
     /// Gets `header.difficulty`.
@@ -824,11 +824,7 @@ impl BlockView {
     ) -> Self {
         let block = packed::Block::new_builder()
             .header(header.data())
-            .transactions(
-                body.iter()
-                    .map(|tx| tx.data())
-                    .collect::<Vec<packed::Transaction>>(),
-            )
+            .transactions(body.iter().map(|tx| tx.data()).pack())
             .uncles(uncles.data())
             .proposals(proposals)
             .build();
@@ -858,11 +854,7 @@ impl BlockView {
     ) -> Self {
         let block = packed::BlockV1::new_builder()
             .header(header.data())
-            .transactions(
-                body.iter()
-                    .map(|tx| tx.data())
-                    .collect::<Vec<packed::Transaction>>(),
-            )
+            .transactions(body.iter().map(|tx| tx.data()).pack())
             .uncles(uncles.data())
             .proposals(proposals)
             .extension(extension)
@@ -952,8 +944,7 @@ impl IntoBlockView for packed::Block {
             .uncles()
             .iter()
             .map(|uncle| uncle.calc_header_hash())
-            .collect::<Vec<_>>()
-            .into();
+            .pack();
         BlockView {
             data: block,
             hash,
diff --git a/util/types/src/extension.rs b/util/types/src/extension.rs
index dbc7f2cc74..2711c8f90d 100644
--- a/util/types/src/extension.rs
+++ b/util/types/src/extension.rs
@@ -11,7 +11,7 @@ use crate::{
 impl Difficulty for packed::RawHeader {
     /// Calculates the difficulty from compact target.
     fn difficulty(&self) -> U256 {
-        compact_to_difficulty(self.compact_target().into())
+        compact_to_difficulty(self.compact_target().unpack())
     }
 }
 
@@ -86,7 +86,7 @@ impl BuildCompactBlock for packed::CompactBlock {
                 || transaction.is_cellbase()
             {
                 let prefilled_tx = packed::IndexTransaction::new_builder()
-                    .index(transaction_index)
+                    .index((transaction_index as u32).pack())
                     .transaction(transaction.data())
                     .build();
                 prefilled_transactions.push(prefilled_tx);
@@ -98,8 +98,8 @@ impl BuildCompactBlock for packed::CompactBlock {
         if let Some(extension) = block.data().extension() {
             packed::CompactBlockV1::new_builder()
                 .header(block.data().header())
-                .short_ids(short_ids)
-                .prefilled_transactions(prefilled_transactions)
+                .short_ids(short_ids.pack())
+                .prefilled_transactions(prefilled_transactions.pack())
                 .uncles(block.uncle_hashes.clone())
                 .proposals(block.data().proposals())
                 .extension(extension)
@@ -108,8 +108,8 @@ impl BuildCompactBlock for packed::CompactBlock {
         } else {
             packed::CompactBlock::new_builder()
                 .header(block.data().header())
-                .short_ids(short_ids)
-                .prefilled_transactions(prefilled_transactions)
+                .short_ids(short_ids.pack())
+                .prefilled_transactions(prefilled_transactions.pack())
                 .uncles(block.uncle_hashes.clone())
                 .proposals(block.data().proposals())
                 .build()
@@ -123,7 +123,7 @@ impl BuildCompactBlock for packed::CompactBlock {
         let prefilled_indexes = self
             .prefilled_transactions()
             .into_iter()
-            .map(|tx_index| tx_index.index().into())
+            .map(|tx_index| tx_index.index().unpack())
             .collect::<HashSet<usize>>();
 
         let mut index = 0;
@@ -143,7 +143,7 @@ impl BuildCompactBlock for packed::CompactBlock {
         let prefilled_indexes_iter = self
             .prefilled_transactions()
             .into_iter()
-            .map(|i| i.index().into());
+            .map(|i| i.index().unpack());
 
         let prefilled_indexes: HashSet<usize> = prefilled_indexes_iter.collect();
 
@@ -180,6 +180,6 @@ mod test {
     fn empty_extra_hash() {
         let block = packed::Block::new_builder().build();
         let expect = h256!("0x0");
-        assert_eq!(block.calc_extra_hash().extra_hash(), expect.into());
+        assert_eq!(block.calc_extra_hash().extra_hash(), expect.pack());
     }
 }
diff --git a/util/types/src/utilities/merkle_mountain_range.rs b/util/types/src/utilities/merkle_mountain_range.rs
index 7cd37afb96..2f8a9d71b4 100644
--- a/util/types/src/utilities/merkle_mountain_range.rs
+++ b/util/types/src/utilities/merkle_mountain_range.rs
@@ -45,7 +45,7 @@ impl core::HeaderView {
         let raw = self.data().raw();
         packed::HeaderDigest::new_builder()
             .children_hash(self.hash())
-            .total_difficulty(self.difficulty())
+            .total_difficulty(self.difficulty().pack())
             .start_number(raw.number())
             .end_number(raw.number())
             .start_epoch(raw.epoch())
@@ -68,8 +68,8 @@ impl HeaderDigest for packed::HeaderDigest {
     /// Verify the MMR header digest
     fn verify(&self) -> Result<(), String> {
         // 1. Check block numbers.
-        let start_number: BlockNumber = self.start_number().into();
-        let end_number: BlockNumber = self.end_number().into();
+        let start_number: BlockNumber = self.start_number().unpack();
+        let end_number: BlockNumber = self.end_number().unpack();
         if start_number > end_number {
             let errmsg = format!(
                 "failed since the start block number is bigger than the end ([{start_number},{end_number}])"
@@ -78,8 +78,8 @@ impl HeaderDigest for packed::HeaderDigest {
         }
 
         // 2. Check epochs.
-        let start_epoch: EpochNumberWithFraction = self.start_epoch().into();
-        let end_epoch: EpochNumberWithFraction = self.end_epoch().into();
+        let start_epoch: EpochNumberWithFraction = self.start_epoch().unpack();
+        let end_epoch: EpochNumberWithFraction = self.end_epoch().unpack();
         let start_epoch_number = start_epoch.number();
         let end_epoch_number = end_epoch.number();
         if start_epoch != end_epoch
@@ -94,9 +94,9 @@ impl HeaderDigest for packed::HeaderDigest {
         }
 
         // 3. Check difficulties when in the same epoch.
-        let start_compact_target: u32 = self.start_compact_target().into();
-        let end_compact_target: u32 = self.end_compact_target().into();
-        let total_difficulty: U256 = self.total_difficulty().into();
+        let start_compact_target: u32 = self.start_compact_target().unpack();
+        let end_compact_target: u32 = self.end_compact_target().unpack();
+        let total_difficulty: U256 = self.total_difficulty().unpack();
         if start_epoch_number == end_epoch_number {
             if start_compact_target != end_compact_target {
                 // In the same epoch, all compact targets should be same.
@@ -137,14 +137,14 @@ impl Merge for MergeHeaderDigest {
         };
 
         let total_difficulty = {
-            let l: U256 = lhs.total_difficulty().into();
-            let r: U256 = rhs.total_difficulty().into();
+            let l: U256 = lhs.total_difficulty().unpack();
+            let r: U256 = rhs.total_difficulty().unpack();
             l + r
         };
 
         // 1. Check block numbers.
-        let lhs_end_number: BlockNumber = lhs.end_number().into();
-        let rhs_start_number: BlockNumber = rhs.start_number().into();
+        let lhs_end_number: BlockNumber = lhs.end_number().unpack();
+        let rhs_start_number: BlockNumber = rhs.start_number().unpack();
         if lhs_end_number + 1 != rhs_start_number {
             let errmsg = format!(
                 "failed since the blocks isn't continuous ([-,{lhs_end_number}], [{rhs_start_number},-])"
@@ -153,8 +153,8 @@ impl Merge for MergeHeaderDigest {
         }
 
         // 2. Check epochs.
-        let lhs_end_epoch: EpochNumberWithFraction = lhs.end_epoch().into();
-        let rhs_start_epoch: EpochNumberWithFraction = rhs.start_epoch().into();
+        let lhs_end_epoch: EpochNumberWithFraction = lhs.end_epoch().unpack();
+        let rhs_start_epoch: EpochNumberWithFraction = rhs.start_epoch().unpack();
         if !rhs_start_epoch.is_successor_of(lhs_end_epoch) && !lhs_end_epoch.is_genesis() {
             let errmsg = format!(
                 "failed since the epochs isn't continuous ([-,{lhs_end_epoch:#}], [{rhs_start_epoch:#},-])",
@@ -163,8 +163,8 @@ impl Merge for MergeHeaderDigest {
         }
 
         Ok(Self::Item::new_builder()
-            .children_hash(children_hash)
-            .total_difficulty(total_difficulty)
+            .children_hash(children_hash.pack())
+            .total_difficulty(total_difficulty.pack())
             .start_number(lhs.start_number())
             .start_epoch(lhs.start_epoch())
             .start_timestamp(lhs.start_timestamp())
@@ -263,7 +263,7 @@ impl VerifiableHeader {
 
     /// Returns the total difficulty.
     pub fn total_difficulty(&self) -> U256 {
-        let parent_total_difficulty: U256 = self.parent_chain_root.total_difficulty().into();
+        let parent_total_difficulty: U256 = self.parent_chain_root.total_difficulty().unpack();
         let block_difficulty = compact_to_difficulty(self.header.compact_target());
         parent_total_difficulty + block_difficulty
     }
diff --git a/util/types/src/utilities/merkle_tree.rs b/util/types/src/utilities/merkle_tree.rs
index c0fba6a54e..75c2e152f2 100644
--- a/util/types/src/utilities/merkle_tree.rs
+++ b/util/types/src/utilities/merkle_tree.rs
@@ -15,7 +15,7 @@ impl Merge for MergeByte32 {
         blake2b.update(left.as_slice());
         blake2b.update(right.as_slice());
         blake2b.finalize(&mut ret);
-        ret.into()
+        ret.pack()
     }
 }
 
diff --git a/verification/contextual/src/contextual_block_verifier.rs b/verification/contextual/src/contextual_block_verifier.rs
index 03ebfd9ad2..74bd483a47 100644
--- a/verification/contextual/src/contextual_block_verifier.rs
+++ b/verification/contextual/src/contextual_block_verifier.rs
@@ -241,7 +241,7 @@ impl<'a, 'b, CS: ChainStore + VersionbitsIndexer> RewardVerifier<'a, 'b, CS> {
 
         let (target_lock, block_reward) = self.context.finalize_block_reward(self.parent)?;
         let output = CellOutput::new_builder()
-            .capacity(block_reward.total)
+            .capacity(block_reward.total.pack())
             .lock(target_lock.clone())
             .build();
         let insufficient_reward_to_create_cell = output.is_lack_of_capacity(Capacity::zero())?;
diff --git a/verification/contextual/src/tests/contextual_block_verifier.rs b/verification/contextual/src/tests/contextual_block_verifier.rs
index b568ab0c2b..fc6c4182d4 100644
--- a/verification/contextual/src/tests/contextual_block_verifier.rs
+++ b/verification/contextual/src/tests/contextual_block_verifier.rs
@@ -13,10 +13,7 @@ use ckb_types::{
         EpochExt, EpochNumberWithFraction, HeaderBuilder, HeaderView, TransactionBuilder,
         TransactionView, UncleBlockView,
     },
-    packed::{
-        self, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, ProposalShortId,
-        Script,
-    },
+    packed::{Byte32, CellDep, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script},
     prelude::*,
     utilities::DIFF_TWO,
 };
@@ -37,15 +34,11 @@ fn gen_block(
     let cellbase = create_cellbase(number);
     let header = HeaderBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(now)
-        .number(number)
-        .epoch(EpochNumberWithFraction::new(
-            number / 1000,
-            number % 1000,
-            1000,
-        ))
-        .compact_target(compact_target)
-        .nonce(nonce)
+        .timestamp(now.pack())
+        .number(number.pack())
+        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
+        .compact_target(compact_target.pack())
+        .nonce(nonce.pack())
         .build();
 
     BlockBuilder::default()
@@ -64,9 +57,9 @@ fn create_transaction(
 ) -> TransactionView {
     let capacity = 100_000_000 / 100_usize;
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(capacity).unwrap())
+        .capacity(Capacity::bytes(capacity).unwrap().pack())
         .lock(always_success_script.to_owned())
-        .type_(Some(always_success_script.to_owned()))
+        .type_(Some(always_success_script.to_owned()).pack())
         .build();
     let inputs: Vec<CellInput> = (0..100)
         .map(|index| CellInput::new(OutPoint::new(parent.clone(), index), 0))
@@ -76,11 +69,9 @@ fn create_transaction(
         .build();
 
     TransactionBuilder::default()
-        .inputs(Into::<packed::CellInputVec>::into(inputs))
-        .outputs(Into::<packed::CellOutputVec>::into(vec![output; 100]))
-        .outputs_data(Into::<packed::BytesVec>::into(
-            vec![Bytes::new(); 100].as_slice(),
-        ))
+        .inputs(inputs.pack())
+        .outputs(vec![output; 100].pack())
+        .outputs_data(vec![Bytes::new(); 100].pack())
         .cell_dep(cell_dep)
         .build()
 }
@@ -104,7 +95,7 @@ fn create_cellbase(number: BlockNumber) -> TransactionView {
     TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(number))
         .output(CellOutputBuilder::default().build())
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build()
 }
 
@@ -117,14 +108,14 @@ fn setup_env() -> (ChainController, Shared, Byte32, Script, OutPoint) {
         .output(always_success_cell.clone())
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1_000_000))
+                .capacity(capacity_bytes!(1_000_000).pack())
                 .lock(always_success_script.clone())
-                .type_(Some(always_success_script.clone()))
+                .type_(Some(always_success_script.clone()).pack())
                 .build();
             100
         ])
-        .output_data(always_success_cell_data.to_owned())
-        .outputs_data(vec![Bytes::new().into(); 100])
+        .output_data(always_success_cell_data.to_owned().pack())
+        .outputs_data(vec![Bytes::new().pack(); 100])
         .build();
     let tx_hash = tx.data().calc_tx_hash();
     let genesis_block = BlockBuilder::default().transaction(tx).build();
@@ -150,8 +141,8 @@ pub fn test_should_have_no_output_in_cellbase_no_finalization_target() {
     let number = parent.number() + 1;
     let cellbase = TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(number))
-        .output(CellOutput::default())
-        .output_data(packed::Bytes::default())
+        .output(Default::default())
+        .output_data(Default::default())
         .build();
 
     let cellbase = ResolvedTransaction {
@@ -169,7 +160,7 @@ pub fn test_should_have_no_output_in_cellbase_no_finalization_target() {
 #[test]
 fn test_epoch_number() {
     let actual_epoch = EpochNumberWithFraction::new(2, 0, 1);
-    let block = BlockBuilder::default().epoch(actual_epoch).build();
+    let block = BlockBuilder::default().epoch(actual_epoch.pack()).build();
     let mut epoch = EpochExt::default();
     epoch.set_length(1);
 
@@ -189,8 +180,8 @@ fn test_epoch_difficulty() {
     epoch.set_length(1);
 
     let block = BlockBuilder::default()
-        .epoch(epoch.number_with_fraction(0))
-        .compact_target(0x200c_30c3u32)
+        .epoch(epoch.number_with_fraction(0).pack())
+        .compact_target(0x200c_30c3u32.pack())
         .build();
 
     assert_error_eq!(
diff --git a/verification/contextual/src/tests/uncle_verifier.rs b/verification/contextual/src/tests/uncle_verifier.rs
index 84dba7b1e7..0928abdee9 100644
--- a/verification/contextual/src/tests/uncle_verifier.rs
+++ b/verification/contextual/src/tests/uncle_verifier.rs
@@ -12,7 +12,7 @@ use ckb_types::{
         BlockBuilder, BlockNumber, BlockView, EpochExt, HeaderView, TransactionBuilder,
         TransactionView, UncleBlockView,
     },
-    packed::{self, CellInput, CellOutput, ProposalShortId, Script},
+    packed::{CellInput, ProposalShortId, Script},
     prelude::*,
 };
 use ckb_verification::UnclesError;
@@ -28,11 +28,11 @@ fn gen_block(parent_header: &HeaderView, nonce: u128, epoch: &EpochExt) -> Block
         .transaction(cellbase)
         .proposal(ProposalShortId::from_slice(&[1; 10]).unwrap())
         .parent_hash(parent_header.hash())
-        .timestamp(now)
-        .epoch(epoch.number_with_fraction(number))
-        .number(number)
-        .compact_target(epoch.compact_target())
-        .nonce(nonce)
+        .timestamp(now.pack())
+        .epoch(epoch.number_with_fraction(number).pack())
+        .number(number.pack())
+        .compact_target(epoch.compact_target().pack())
+        .nonce(nonce.pack())
         .build()
 }
 
@@ -52,8 +52,8 @@ fn create_cellbase(number: BlockNumber) -> TransactionView {
     TransactionBuilder::default()
         .witness(Script::default().into_witness())
         .input(CellInput::new_cellbase_input(number))
-        .output(CellOutput::default())
-        .output_data(packed::Bytes::default())
+        .output(Default::default())
+        .output_data(Default::default())
         .build()
 }
 
@@ -169,7 +169,7 @@ fn test_invalid_target() {
     let uncle = chain2[16]
         .clone()
         .as_advanced_builder()
-        .compact_target(invalid_target)
+        .compact_target(invalid_target.pack())
         .build()
         .as_uncle();
     let block = chain2[18]
@@ -194,7 +194,7 @@ fn test_invalid_epoch() {
     let uncle = chain2[uncle_number]
         .clone()
         .as_advanced_builder()
-        .compact_target(chain1[block_number].compact_target())
+        .compact_target(chain1[block_number].compact_target().pack())
         .build()
         .as_uncle();
     let block = chain1[block_number]
@@ -245,7 +245,7 @@ fn test_uncle_proposals_hash() {
         .to_owned()
         .as_advanced_builder()
         .parent_hash(chain1[15].hash())
-        .proposal([1; 10])
+        .proposal([1; 10].pack())
         .build_unchecked()
         .as_uncle();
     let block = chain1[18]
@@ -270,7 +270,7 @@ fn test_uncle_duplicated_proposals() {
     let uncle = chain2[6]
         .to_owned()
         .as_advanced_builder()
-        .proposal([1; 10])
+        .proposal([1; 10].pack())
         .build()
         .as_uncle();
     let block = chain1[8]
diff --git a/verification/src/tests/block_verifier.rs b/verification/src/tests/block_verifier.rs
index 112666849d..e2638882ef 100644
--- a/verification/src/tests/block_verifier.rs
+++ b/verification/src/tests/block_verifier.rs
@@ -22,10 +22,10 @@ fn create_cellbase_transaction_with_block_number(number: BlockNumber) -> Transac
         .input(CellInput::new_cellbase_input(number))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -33,8 +33,12 @@ fn create_cellbase_transaction_with_block_number(number: BlockNumber) -> Transac
 fn create_cellbase_transaction_with_capacity(capacity: Capacity) -> TransactionView {
     TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(0))
-        .output(CellOutputBuilder::default().capacity(capacity).build())
-        .output_data(Bytes::new())
+        .output(
+            CellOutputBuilder::default()
+                .capacity(capacity.pack())
+                .build(),
+        )
+        .output_data(Bytes::new().pack())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -44,10 +48,10 @@ fn create_cellbase_transaction_with_non_empty_output_data() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
-        .output_data(Bytes::from("123"))
+        .output_data(Bytes::from("123").pack())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -57,15 +61,15 @@ fn create_cellbase_transaction_with_two_output() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -75,11 +79,11 @@ fn create_cellbase_transaction_with_two_output_data() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
-        .output_data(Bytes::new())
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().pack())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -90,13 +94,13 @@ fn create_cellbase_transaction() -> TransactionView {
 
 fn create_normal_transaction() -> TransactionView {
     TransactionBuilder::default()
-        .input(CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0))
+        .input(CellInput::new(OutPoint::new(h256!("0x1").pack(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build()
 }
 
@@ -191,7 +195,7 @@ pub fn test_cellbase_without_output() {
     let cellbase_without_output = TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(2u64))
         .witness(Script::default().into_witness())
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
     let block = BlockBuilder::new_with_number(2)
         .transaction(cellbase_without_output)
@@ -205,7 +209,7 @@ pub fn test_cellbase_without_output() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         )
         .build();
@@ -289,7 +293,7 @@ pub fn test_transaction_root() {
 #[test]
 pub fn test_proposals_root() {
     let header = HeaderBuilder::new_with_number(2)
-        .proposals_hash(h256!("0x1"))
+        .proposals_hash(h256!("0x1").pack())
         .build();
     let block = BlockBuilder::default()
         .header(header)
diff --git a/verification/src/tests/genesis_verifier.rs b/verification/src/tests/genesis_verifier.rs
index d11bda96e3..716ef144c4 100644
--- a/verification/src/tests/genesis_verifier.rs
+++ b/verification/src/tests/genesis_verifier.rs
@@ -1,7 +1,7 @@
 use crate::{genesis_verifier::GenesisVerifier, NumberError, UnknownParentError};
 use ckb_chain_spec::consensus::{Consensus, ConsensusBuilder};
 use ckb_error::assert_error_eq;
-use ckb_types::core::EpochNumberWithFraction;
+use ckb_types::{core::EpochNumberWithFraction, prelude::*};
 use ckb_verification_traits::Verifier;
 
 #[test]
@@ -9,8 +9,8 @@ pub fn test_genesis_non_zero_number() {
     let genesis_block = Consensus::default().genesis_block().to_owned();
     let genesis_block = genesis_block
         .as_advanced_builder()
-        .number(42)
-        .epoch(EpochNumberWithFraction::from_full_value(0))
+        .number(42.pack())
+        .epoch(EpochNumberWithFraction::from_full_value(0).pack())
         .build();
     let consensus = ConsensusBuilder::default()
         .genesis_block(genesis_block)
@@ -30,7 +30,7 @@ pub fn test_genesis_non_zero_parent_hash() {
     let genesis_block = Consensus::default().genesis_block().to_owned();
     let genesis_block = genesis_block
         .as_advanced_builder()
-        .parent_hash([42u8; 32])
+        .parent_hash([42u8; 32].pack())
         .build();
     let consensus = ConsensusBuilder::default()
         .genesis_block(genesis_block)
@@ -39,7 +39,7 @@ pub fn test_genesis_non_zero_parent_hash() {
     assert_error_eq!(
         verifier.verify(&consensus).unwrap_err(),
         UnknownParentError {
-            parent_hash: [42u8; 32].into()
+            parent_hash: [42u8; 32].pack()
         },
     );
 }
diff --git a/verification/src/tests/header_verifier.rs b/verification/src/tests/header_verifier.rs
index b42269ba34..8fe6abbbaa 100644
--- a/verification/src/tests/header_verifier.rs
+++ b/verification/src/tests/header_verifier.rs
@@ -15,6 +15,7 @@ use ckb_types::{
         EpochNumberWithFraction, HeaderBuilder,
     },
     packed::Header,
+    prelude::*,
 };
 
 use super::BuilderBaseOnBlockNumber;
@@ -40,7 +41,7 @@ pub fn test_version() {
         .build();
 
     let header = HeaderBuilder::default()
-        .version(consensus.block_version() + 1)
+        .version((consensus.block_version() + 1).pack())
         .build();
     let verifier = VersionVerifier::new(&header, &consensus);
 
@@ -53,8 +54,8 @@ pub fn test_version() {
     );
     let epoch = EpochNumberWithFraction::new(10, 40, 1000);
     let header = HeaderBuilder::default()
-        .version(consensus.block_version() + 1)
-        .epoch(epoch)
+        .version((consensus.block_version() + 1).pack())
+        .epoch(epoch.pack())
         .build();
     let verifier = VersionVerifier::new(&header, &consensus);
     assert!(verifier.verify().is_ok());
@@ -69,7 +70,7 @@ fn test_timestamp() {
     let timestamp = unix_time_as_millis() + 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp)
+        .timestamp(timestamp.pack())
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -91,7 +92,7 @@ fn test_timestamp_too_old() {
     let timestamp = unix_time_as_millis() - 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp)
+        .timestamp(timestamp.pack())
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -119,7 +120,7 @@ fn test_timestamp_too_new() {
     let timestamp = max + 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp)
+        .timestamp(timestamp.pack())
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -161,7 +162,9 @@ fn test_epoch() {
         ];
 
         for epoch_malformed in epochs_malformed {
-            let malformed = HeaderBuilder::default().epoch(epoch_malformed).build();
+            let malformed = HeaderBuilder::default()
+                .epoch(epoch_malformed.pack())
+                .build();
             let result = EpochVerifier::new(parent, &malformed).verify();
             assert!(result.is_err(), "input: {epoch_malformed:#}");
             assert_error_eq!(
@@ -205,7 +208,7 @@ fn test_epoch() {
         ];
 
         for (parent, epoch_current) in epochs {
-            let current = HeaderBuilder::default().epoch(epoch_current).build();
+            let current = HeaderBuilder::default().epoch(epoch_current.pack()).build();
 
             let result = EpochVerifier::new(parent, &current).verify();
             assert!(result.is_err(), "current: {current:#}, parent: {parent:#}");
@@ -234,7 +237,7 @@ fn test_epoch() {
             ),
         ];
         for (parent, epoch_current) in epochs {
-            let current = HeaderBuilder::default().epoch(epoch_current).build();
+            let current = HeaderBuilder::default().epoch(epoch_current.pack()).build();
 
             let result = EpochVerifier::new(parent, &current).verify();
             assert!(result.is_ok(), "current: {current:#}, parent: {parent:#}");
diff --git a/verification/src/tests/mod.rs b/verification/src/tests/mod.rs
index 9fbb34f345..9f1eab8a67 100644
--- a/verification/src/tests/mod.rs
+++ b/verification/src/tests/mod.rs
@@ -5,7 +5,10 @@ mod genesis_verifier;
 mod header_verifier;
 mod transaction_verifier;
 
-use ckb_types::core::{BlockBuilder, BlockNumber, EpochNumberWithFraction, HeaderBuilder};
+use ckb_types::{
+    core::{BlockBuilder, BlockNumber, EpochNumberWithFraction, HeaderBuilder},
+    prelude::*,
+};
 
 trait BuilderBaseOnBlockNumber {
     fn new_with_number(number: BlockNumber) -> Self;
@@ -14,23 +17,15 @@ trait BuilderBaseOnBlockNumber {
 impl BuilderBaseOnBlockNumber for HeaderBuilder {
     fn new_with_number(number: BlockNumber) -> HeaderBuilder {
         Self::default()
-            .number(number)
-            .epoch(EpochNumberWithFraction::new(
-                number / 1000,
-                number % 1000,
-                1000,
-            ))
+            .number(number.pack())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
     }
 }
 
 impl BuilderBaseOnBlockNumber for BlockBuilder {
     fn new_with_number(number: BlockNumber) -> BlockBuilder {
         Self::default()
-            .number(number)
-            .epoch(EpochNumberWithFraction::new(
-                number / 1000,
-                number % 1000,
-                1000,
-            ))
+            .number(number.pack())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
     }
 }
diff --git a/verification/src/tests/transaction_verifier.rs b/verification/src/tests/transaction_verifier.rs
index 57f2913ca8..16f05fe1fe 100644
--- a/verification/src/tests/transaction_verifier.rs
+++ b/verification/src/tests/transaction_verifier.rs
@@ -23,7 +23,7 @@ use ckb_types::{
         TransactionBuilder, TransactionInfo, TransactionView,
     },
     h256,
-    packed::{self, Byte32, CellDep, CellInput, CellOutput, OutPoint, Script},
+    packed::{Byte32, CellDep, CellInput, CellOutput, OutPoint, Script},
     prelude::*,
 };
 use std::sync::Arc;
@@ -44,7 +44,7 @@ pub fn test_empty() {
 #[test]
 pub fn test_version() {
     let transaction = TransactionBuilder::default()
-        .version(TX_VERSION + 1)
+        .version((TX_VERSION + 1).pack())
         .build();
     let verifier = VersionVerifier::new(&transaction, TX_VERSION);
 
@@ -63,10 +63,10 @@ pub fn test_exceeded_maximum_block_bytes() {
     let transaction = TransactionBuilder::default()
         .output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
         )
-        .output_data(data)
+        .output_data(data.pack())
         .build();
     let verifier = SizeVerifier::new(&transaction, 100);
 
@@ -85,10 +85,10 @@ pub fn test_capacity_outofbound() {
     let transaction = TransactionBuilder::default()
         .output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
         )
-        .output_data(data)
+        .output_data(data.pack())
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -96,7 +96,7 @@ pub fn test_capacity_outofbound() {
         resolved_cell_deps: Vec::new(),
         resolved_inputs: vec![CellMetaBuilder::from_cell_output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             Bytes::new(),
         )
@@ -123,11 +123,11 @@ pub fn test_skip_dao_capacity_check() {
     let transaction = TransactionBuilder::default()
         .output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(500))
-                .type_(Some(dao_type_script.clone()))
+                .capacity(capacity_bytes!(500).pack())
+                .type_(Some(dao_type_script.clone()).pack())
                 .build(),
         )
-        .output_data(Bytes::new())
+        .output_data(Bytes::new().pack())
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -146,7 +146,7 @@ pub fn test_skip_dao_capacity_check() {
 pub fn test_inputs_cellbase_maturity() {
     let transaction = TransactionBuilder::default().build();
     let output = CellOutput::new_builder()
-        .capacity(capacity_bytes!(50))
+        .capacity(capacity_bytes!(50).pack())
         .build();
     let base_epoch = EpochNumberWithFraction::new(10, 0, 10);
     let cellbase_maturity = EpochNumberWithFraction::new(5, 0, 1);
@@ -197,7 +197,7 @@ pub fn test_inputs_cellbase_maturity() {
 fn test_ignore_genesis_cellbase_maturity() {
     let transaction = TransactionBuilder::default().build();
     let output = CellOutput::new_builder()
-        .capacity(capacity_bytes!(50))
+        .capacity(capacity_bytes!(50).pack())
         .build();
     let base_epoch = EpochNumberWithFraction::new(0, 0, 10);
     let cellbase_maturity = EpochNumberWithFraction::new(5, 0, 1);
@@ -236,7 +236,7 @@ fn test_ignore_genesis_cellbase_maturity() {
 pub fn test_deps_cellbase_maturity() {
     let transaction = TransactionBuilder::default().build();
     let output = CellOutput::new_builder()
-        .capacity(capacity_bytes!(50))
+        .capacity(capacity_bytes!(50).pack())
         .build();
 
     let base_epoch = EpochNumberWithFraction::new(0, 0, 10);
@@ -296,13 +296,13 @@ pub fn test_capacity_invalid() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(100))
+                .capacity(capacity_bytes!(100).pack())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().into(); 2])
+        .outputs_data(vec![Bytes::new().pack(); 2])
         .build();
 
     // The inputs capacity is 49 + 100 = 149,
@@ -313,14 +313,14 @@ pub fn test_capacity_invalid() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(49))
+                    .capacity(capacity_bytes!(49).pack())
                     .build(),
                 Bytes::new(),
             )
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(100))
+                    .capacity(capacity_bytes!(100).pack())
                     .build(),
                 Bytes::new(),
             )
@@ -342,7 +342,7 @@ pub fn test_capacity_invalid() {
 
 #[test]
 pub fn test_duplicate_cell_deps() {
-    let out_point = OutPoint::new(h256!("0x1").into(), 0);
+    let out_point = OutPoint::new(h256!("0x1").pack(), 0);
     let cell_dep = CellDep::new_builder().out_point(out_point).build();
     let transaction = TransactionBuilder::default()
         .cell_deps(vec![cell_dep.clone(), cell_dep.clone()])
@@ -361,7 +361,7 @@ pub fn test_duplicate_cell_deps() {
 #[test]
 pub fn test_duplicate_header_deps() {
     let transaction = TransactionBuilder::default()
-        .header_deps(vec![h256!("0x1").into(), h256!("0x1").into()])
+        .header_deps(vec![h256!("0x1").pack(), h256!("0x1").pack()])
         .build();
 
     let verifier = DuplicateDepsVerifier::new(&transaction);
@@ -369,7 +369,7 @@ pub fn test_duplicate_header_deps() {
     assert_error_eq!(
         verifier.verify().unwrap_err(),
         TransactionError::DuplicateHeaderDeps {
-            hash: h256!("0x1").into()
+            hash: h256!("0x1").pack()
         },
     );
 }
@@ -389,8 +389,8 @@ fn verify_since(
     let tx_env = {
         let epoch = EpochNumberWithFraction::new(epoch_number, 0, 10);
         let header = HeaderView::new_advanced_builder()
-            .number(block_number)
-            .epoch(epoch)
+            .number(block_number.pack())
+            .epoch(epoch.pack())
             .parent_hash(parent_hash.as_ref().to_owned())
             .build();
         Arc::new(TxVerifyEnv::new_commit(&header))
@@ -429,7 +429,7 @@ fn test_since() {
 fn create_tx_with_lock(since: u64) -> TransactionView {
     TransactionBuilder::default()
         .inputs(vec![CellInput::new(
-            OutPoint::new(h256!("0x1").into(), 0),
+            OutPoint::new(h256!("0x1").pack(), 0),
             since,
         )])
         .build()
@@ -444,7 +444,7 @@ fn create_resolve_tx_with_transaction_info(
         resolved_cell_deps: Vec::new(),
         resolved_inputs: vec![CellMetaBuilder::from_cell_output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             Bytes::new(),
         )
@@ -503,8 +503,8 @@ fn test_fraction_epoch_since_verify() {
     let tx_env = {
         let epoch = EpochNumberWithFraction::new(16, 1, 10);
         let header = HeaderView::new_advanced_builder()
-            .number(block_number)
-            .epoch(epoch)
+            .number(block_number.pack())
+            .epoch(epoch.pack())
             .parent_hash(parent_hash.as_ref().to_owned())
             .build();
         Arc::new(TxVerifyEnv::new_commit(&header))
@@ -521,8 +521,8 @@ fn test_fraction_epoch_since_verify() {
     let tx_env = {
         let epoch = EpochNumberWithFraction::new(16, 5, 10);
         let header = HeaderView::new_advanced_builder()
-            .number(block_number)
-            .epoch(epoch)
+            .number(block_number.pack())
+            .epoch(epoch.pack())
             .parent_hash(parent_hash.as_ref().to_owned())
             .build();
         Arc::new(TxVerifyEnv::new_commit(&header))
@@ -547,8 +547,8 @@ fn test_fraction_epoch_since_verify_v2021() {
         let epoch = EpochNumberWithFraction::new(16, 5, 10);
         let parent_hash = Arc::new(median_time_context.get_block_hash(block_number - 1));
         let header = HeaderView::new_advanced_builder()
-            .number(block_number)
-            .epoch(epoch)
+            .number(block_number.pack())
+            .epoch(epoch.pack())
             .parent_hash(parent_hash.as_ref().to_owned())
             .build();
         Arc::new(TxVerifyEnv::new_commit(&header))
@@ -666,9 +666,9 @@ pub fn test_since_both() {
     let tx = TransactionBuilder::default()
         .inputs(vec![
             // absolute lock until epoch number 0xa
-            CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0x0000_0000_0000_000a),
+            CellInput::new(OutPoint::new(h256!("0x1").pack(), 0), 0x0000_0000_0000_000a),
             // relative lock until after 2 blocks
-            CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0xc000_0000_0000_0002),
+            CellInput::new(OutPoint::new(h256!("0x1").pack(), 0), 0xc000_0000_0000_0002),
         ])
         .build();
     // spent after 1024 seconds and 4 blocks (less than 10 blocks)
@@ -741,7 +741,7 @@ fn test_since_overflow() {
 #[test]
 pub fn test_outputs_data_length_mismatch() {
     let transaction = TransactionBuilder::default()
-        .output(CellOutput::default())
+        .output(Default::default())
         .build();
     let verifier = OutputsDataVerifier::new(&transaction);
 
@@ -754,8 +754,8 @@ pub fn test_outputs_data_length_mismatch() {
     );
 
     let transaction = TransactionBuilder::default()
-        .output(CellOutput::default())
-        .output_data(packed::Bytes::default())
+        .output(Default::default())
+        .output_data(Default::default())
         .build();
     let verifier = OutputsDataVerifier::new(&transaction);
 
@@ -812,7 +812,7 @@ fn build_consensus_with_dao_limiting_block(block_number: u64) -> (Arc<Consensus>
 
     let dao_type_script = Script::new_builder()
         .code_hash(dao_script.calc_script_hash())
-        .hash_type(ScriptHashType::Type)
+        .hash_type(ScriptHashType::Type.into())
         .build();
 
     (Arc::new(consensus), dao_type_script)
@@ -825,15 +825,19 @@ fn test_dao_disables_different_lock_script_size() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200))
-                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
-                .type_(Some(dao_type_script.clone()))
+                .capacity(capacity_bytes!(200).pack())
+                .lock(
+                    Script::new_builder()
+                        .args(Bytes::from(vec![1; 20]).pack())
+                        .build(),
+                )
+                .type_(Some(dao_type_script.clone()).pack())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().into(); 2])
+        .outputs_data(vec![Bytes::new().pack(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -842,7 +846,7 @@ fn test_dao_disables_different_lock_script_size() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50))
+                    .capacity(capacity_bytes!(50).pack())
                     .build(),
                 Bytes::new(),
             )
@@ -854,9 +858,9 @@ fn test_dao_disables_different_lock_script_size() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201))
-                    .lock(Script::new_builder().args(Bytes::new()).build())
-                    .type_(Some(dao_type_script))
+                    .capacity(capacity_bytes!(201).pack())
+                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
+                    .type_(Some(dao_type_script).pack())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -884,15 +888,19 @@ fn test_dao_disables_different_lock_script_size_before_limiting_block() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200))
-                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
-                .type_(Some(dao_type_script.clone()))
+                .capacity(capacity_bytes!(200).pack())
+                .lock(
+                    Script::new_builder()
+                        .args(Bytes::from(vec![1; 20]).pack())
+                        .build(),
+                )
+                .type_(Some(dao_type_script.clone()).pack())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().into(); 2])
+        .outputs_data(vec![Bytes::new().pack(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -901,7 +909,7 @@ fn test_dao_disables_different_lock_script_size_before_limiting_block() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50))
+                    .capacity(capacity_bytes!(50).pack())
                     .build(),
                 Bytes::new(),
             )
@@ -913,9 +921,9 @@ fn test_dao_disables_different_lock_script_size_before_limiting_block() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201))
-                    .lock(Script::new_builder().args(Bytes::new()).build())
-                    .type_(Some(dao_type_script))
+                    .capacity(capacity_bytes!(201).pack())
+                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
+                    .type_(Some(dao_type_script).pack())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -940,14 +948,18 @@ fn test_non_dao_allows_lock_script_size() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200))
-                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
+                .capacity(capacity_bytes!(200).pack())
+                .lock(
+                    Script::new_builder()
+                        .args(Bytes::from(vec![1; 20]).pack())
+                        .build(),
+                )
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().into(); 2])
+        .outputs_data(vec![Bytes::new().pack(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -956,7 +968,7 @@ fn test_non_dao_allows_lock_script_size() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50))
+                    .capacity(capacity_bytes!(50).pack())
                     .build(),
                 Bytes::new(),
             )
@@ -968,8 +980,8 @@ fn test_non_dao_allows_lock_script_size() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201))
-                    .lock(Script::new_builder().args(Bytes::new()).build())
+                    .capacity(capacity_bytes!(201).pack())
+                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -994,15 +1006,19 @@ fn test_dao_allows_different_lock_script_size_in_withdraw_phase_2() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200))
-                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
-                .type_(Some(dao_type_script.clone()))
+                .capacity(capacity_bytes!(200).pack())
+                .lock(
+                    Script::new_builder()
+                        .args(Bytes::from(vec![1; 20]).pack())
+                        .build(),
+                )
+                .type_(Some(dao_type_script.clone()).pack())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().into(); 2])
+        .outputs_data(vec![Bytes::new().pack(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -1011,7 +1027,7 @@ fn test_dao_allows_different_lock_script_size_in_withdraw_phase_2() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50))
+                    .capacity(capacity_bytes!(50).pack())
                     .build(),
                 Bytes::new(),
             )
@@ -1023,9 +1039,9 @@ fn test_dao_allows_different_lock_script_size_in_withdraw_phase_2() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201))
-                    .lock(Script::new_builder().args(Bytes::new()).build())
-                    .type_(Some(dao_type_script))
+                    .capacity(capacity_bytes!(201).pack())
+                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
+                    .type_(Some(dao_type_script).pack())
                     .build(),
                 Bytes::from(vec![1; 8]),
             )
@@ -1050,12 +1066,16 @@ fn test_dao_allows_different_lock_script_size_using_normal_cells_in_withdraw_pha
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50))
+                .capacity(capacity_bytes!(50).pack())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200))
-                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
-                .type_(Some(dao_type_script))
+                .capacity(capacity_bytes!(200).pack())
+                .lock(
+                    Script::new_builder()
+                        .args(Bytes::from(vec![1; 20]).pack())
+                        .build(),
+                )
+                .type_(Some(dao_type_script).pack())
                 .build(),
         ])
         .outputs_data(vec![])
@@ -1067,7 +1087,7 @@ fn test_dao_allows_different_lock_script_size_using_normal_cells_in_withdraw_pha
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50))
+                    .capacity(capacity_bytes!(50).pack())
                     .build(),
                 Bytes::new(),
             )
@@ -1079,8 +1099,8 @@ fn test_dao_allows_different_lock_script_size_using_normal_cells_in_withdraw_pha
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201))
-                    .lock(Script::new_builder().args(Bytes::new()).build())
+                    .capacity(capacity_bytes!(201).pack())
+                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
                     .build(),
                 Bytes::from(vec![1; 8]),
             )
diff --git a/verification/src/transaction_verifier.rs b/verification/src/transaction_verifier.rs
index ff044346aa..b6317cebaa 100644
--- a/verification/src/transaction_verifier.rs
+++ b/verification/src/transaction_verifier.rs
@@ -15,6 +15,7 @@ use ckb_types::{
         Capacity, Cycle, EpochNumberWithFraction, ScriptHashType, TransactionView, Version,
     },
     packed::{Byte32, CellOutput},
+    prelude::*,
 };
 use std::collections::HashSet;
 use std::sync::Arc;
@@ -506,7 +507,7 @@ impl CapacityVerifier {
                 return Err((TransactionError::InsufficientCellCapacity {
                     index,
                     inner: TransactionErrorSource::Outputs,
-                    capacity: output.capacity().into(),
+                    capacity: output.capacity().unpack(),
                     occupied_capacity: output.occupied_capacity(data_occupied_capacity)?,
                 })
                 .into());
@@ -737,7 +738,7 @@ impl<DL: HeaderFieldsProvider> SinceVerifier<DL> {
             .enumerate()
         {
             // ignore empty since
-            let since: u64 = input.since().into();
+            let since: u64 = input.since().unpack();
             if since == 0 {
                 continue;
             }