From 74032482e6ec423dd9fcb4a6dfa65266a6a44826 Mon Sep 17 00:00:00 2001
From: driftluo <driftluo@foxmail.com>
Date: Fri, 5 Jul 2024 14:34:39 +0800
Subject: [PATCH 1/3] feat: basic impl for molecule

---
 .../src/conversion/blockchain/mod.rs          |  55 ++
 .../src/conversion/blockchain/std_env.rs      |  61 ++
 util/gen-types/src/conversion/primitive.rs    | 236 +++++++
 util/gen-types/src/conversion/utilities.rs    | 106 +++
 util/gen-types/src/extension/capacity.rs      |   6 +-
 .../src/extension/rust_core_traits.rs         |  18 +-
 util/gen-types/src/extension/shortcut.rs      |  20 +-
 util/gen-types/src/generated/blockchain.rs    | 615 ++++++++++++++++--
 util/gen-types/src/generated/extensions.rs    | 591 ++++++++++++++---
 util/gen-types/src/generated/protocols.rs     | 154 ++++-
 10 files changed, 1655 insertions(+), 207 deletions(-)

diff --git a/util/gen-types/src/conversion/blockchain/mod.rs b/util/gen-types/src/conversion/blockchain/mod.rs
index b80804fc09..3a73bd2084 100644
--- a/util/gen-types/src/conversion/blockchain/mod.rs
+++ b/util/gen-types/src/conversion/blockchain/mod.rs
@@ -9,6 +9,12 @@ 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];
@@ -18,6 +24,14 @@ impl<'r> Unpack<[u8; 32]> for packed::Byte32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!([u8; 32], Byte32);
 
+impl<'r> Into<[u8; 32]> for packed::Byte32Reader<'r> {
+    fn into(self) -> [u8; 32] {
+        let mut b = [0u8; 32];
+        b.copy_from_slice(self.raw_data());
+        b
+    }
+}
+
 impl Pack<packed::ProposalShortId> for [u8; 10] {
     fn pack(&self) -> packed::ProposalShortId {
         packed::ProposalShortId::from_slice(&self[..])
@@ -34,6 +48,14 @@ impl<'r> Unpack<[u8; 10]> for packed::ProposalShortIdReader<'r> {
 }
 impl_conversion_for_entity_unpack!([u8; 10], ProposalShortId);
 
+impl<'r> Into<[u8; 10]> for packed::ProposalShortIdReader<'r> {
+    fn into(self) -> [u8; 10] {
+        let mut b = [0u8; 10];
+        b.copy_from_slice(self.raw_data());
+        b
+    }
+}
+
 impl Pack<packed::Bytes> for Bytes {
     fn pack(&self) -> packed::Bytes {
         let len = (self.len() as u32).to_le_bytes();
@@ -44,18 +66,46 @@ 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> Into<Bytes> for packed::BytesReader<'r> {
+    fn into(self) -> Bytes {
+        Bytes::from(self.raw_data().to_owned())
+    }
+}
+
 impl Unpack<Bytes> for packed::Bytes {
     fn unpack(&self) -> Bytes {
         self.raw_data()
     }
 }
 
+impl Into<Bytes> for packed::Bytes {
+    fn into(self) -> Bytes {
+        self.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);
@@ -70,3 +120,8 @@ 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 5fd0f40751..93343709b3 100644
--- a/util/gen-types/src/conversion/blockchain/std_env.rs
+++ b/util/gen-types/src/conversion/blockchain/std_env.rs
@@ -10,6 +10,18 @@ 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())
@@ -17,12 +29,32 @@ impl<'r> Unpack<Capacity> for packed::Uint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(Capacity, Uint64);
 
+impl<'r> Into<Capacity> for packed::Uint64Reader<'r> {
+    fn into(self) -> Capacity {
+        Capacity::shannons(self.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")
@@ -30,12 +62,31 @@ impl<'r> Unpack<U256> for packed::Uint256Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(U256, Uint256);
 
+impl<'r> Into<U256> for packed::Uint256Reader<'r> {
+    fn into(self) -> U256 {
+        U256::from_little_endian(self.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")
@@ -43,5 +94,15 @@ impl<'r> Unpack<H256> for packed::Byte32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(H256, Byte32);
 
+impl<'r> Into<H256> for packed::Byte32Reader<'r> {
+    fn into(self) -> H256 {
+        H256::from_slice(self.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 38d82d9228..80ef6b55de 100644
--- a/util/gen-types/src/conversion/primitive.rs
+++ b/util/gen-types/src/conversion/primitive.rs
@@ -1,5 +1,6 @@
 #[cfg(not(feature = "std"))]
 use alloc::{borrow::ToOwned, str, string::String};
+use core::usize;
 #[cfg(feature = "std")]
 use std::str;
 
@@ -12,6 +13,29 @@ 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> Into<bool> for packed::BoolReader<'r> {
+    fn into(self) -> bool {
+        match self.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] {
@@ -29,24 +53,80 @@ 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> Into<u32> for packed::Uint32Reader<'r> {
+    fn into(self) -> u32 {
+        let mut b = [0u8; 4];
+        b.copy_from_slice(self.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];
@@ -56,6 +136,14 @@ impl<'r> Unpack<u32> for packed::Uint32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u32, Uint32);
 
+impl<'r> Into<u64> for packed::Uint64Reader<'r> {
+    fn into(self) -> u64 {
+        let mut b = [0u8; 8];
+        b.copy_from_slice(self.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];
@@ -65,6 +153,14 @@ impl<'r> Unpack<u64> for packed::Uint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u64, Uint64);
 
+impl<'r> Into<u128> for packed::Uint128Reader<'r> {
+    fn into(self) -> u128 {
+        let mut b = [0u8; 16];
+        b.copy_from_slice(self.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];
@@ -74,6 +170,13 @@ impl<'r> Unpack<u128> for packed::Uint128Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u128, Uint128);
 
+impl<'r> Into<usize> for packed::Uint32Reader<'r> {
+    fn into(self) -> usize {
+        let x: u32 = self.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();
@@ -88,18 +191,62 @@ 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> Into<u32> for packed::BeUint32Reader<'r> {
+    fn into(self) -> u32 {
+        let mut b = [0u8; 4];
+        b.copy_from_slice(self.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];
@@ -109,6 +256,14 @@ impl<'r> Unpack<u32> for packed::BeUint32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u32, BeUint32);
 
+impl<'r> Into<u64> for packed::BeUint64Reader<'r> {
+    fn into(self) -> u64 {
+        let mut b = [0u8; 8];
+        b.copy_from_slice(self.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];
@@ -118,6 +273,13 @@ impl<'r> Unpack<u64> for packed::BeUint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u64, BeUint64);
 
+impl<'r> Into<usize> for packed::BeUint32Reader<'r> {
+    fn into(self) -> usize {
+        let x: u32 = self.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();
@@ -136,6 +298,34 @@ 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> Into<Vec<u8>> for packed::BytesReader<'r> {
+    fn into(self) -> Vec<u8> {
+        self.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()
@@ -149,6 +339,12 @@ 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> {
@@ -178,12 +374,24 @@ 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> Into<Option<Vec<u64>>> for packed::Uint64VecOptReader<'r> {
+    fn into(self) -> Option<Vec<u64>> {
+        self.to_opt().map(|x| x.into())
+    }
+}
+
 impl_conversion_for_entity_unpack!(Option<Vec<u64>>, Uint64VecOpt);
 
 impl Pack<packed::Uint64VecOpt> for Option<Vec<u64>> {
@@ -198,6 +406,24 @@ 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);
@@ -206,3 +432,13 @@ 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 cd5faa9a78..7ddb20265b 100644
--- a/util/gen-types/src/conversion/utilities.rs
+++ b/util/gen-types/src/conversion/utilities.rs
@@ -8,6 +8,22 @@ 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> {
@@ -22,6 +38,22 @@ 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> {
@@ -33,6 +65,17 @@ macro_rules! impl_conversion_for_option_unpack {
     };
 }
 
+macro_rules! impl_conversion_for_option_into {
+    ($original:ty, $entity:ident, $reader:ident) => {
+        impl<'r> Into<Option<$original>> for packed::$reader<'r> {
+            fn into(self) -> Option<$original> {
+                self.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);
@@ -40,6 +83,13 @@ 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_into!($original, $entity, $reader);
+    };
+}
+
 macro_rules! impl_conversion_for_vector_pack {
     ($original:ty, $entity:ident) => {
         impl Pack<packed::$entity> for [$original] {
@@ -52,6 +102,30 @@ 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> {
@@ -63,6 +137,17 @@ macro_rules! impl_conversion_for_vector_unpack {
     };
 }
 
+macro_rules! impl_conversion_for_vector_into {
+    ($original:ty, $entity:ident, $reader:ident) => {
+        impl<'r> Into<Vec<$original>> for packed::$reader<'r> {
+            fn into(self) -> Vec<$original> {
+                self.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);
@@ -70,6 +155,13 @@ 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_into!($original, $entity, $reader);
+    };
+}
+
 macro_rules! impl_conversion_for_packed_optional_pack {
     ($original:ident, $entity:ident) => {
         impl Pack<packed::$entity> for Option<packed::$original> {
@@ -84,6 +176,20 @@ 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/capacity.rs b/util/gen-types/src/extension/capacity.rs
index ac4478378f..7e958d49da 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().unpack())
+            .map(|cap| cap > self.capacity().into())
     }
 }
 
@@ -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.pack()).build())
+            .map(|x| self.capacity(x.into()).build())
     }
 }
 
@@ -83,7 +83,7 @@ impl packed::CellOutputVec {
         self.as_reader()
             .iter()
             .map(|output| {
-                let cap: Capacity = output.capacity().unpack();
+                let cap: Capacity = output.capacity().into();
                 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 792895cf93..631224abdb 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.unpack();
-        let other_val: u32 = other.unpack();
+        let self_val: u32 = self.as_reader().into();
+        let other_val: u32 = other.as_reader().into();
         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.unpack();
-        let other_val: u64 = other.unpack();
+        let self_val: u64 = self.as_reader().into();
+        let other_val: u64 = other.as_reader().into();
         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.unpack();
-        let other_val: u128 = other.unpack();
+        let self_val: u128 = self.as_reader().into();
+        let other_val: u128 = other.as_reader().into();
         self_val.cmp(&other_val)
     }
 }
@@ -81,14 +81,14 @@ impl_cmp_partial_ord!(Uint128);
 
 #[cfg(feature = "std")]
 mod std_feature_mod {
-    use crate::{packed, prelude::*};
+    use crate::packed;
     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.unpack();
-            let other_val: U256 = other.unpack();
+            let self_val: U256 = self.as_reader().into();
+            let other_val: U256 = other.as_reader().into();
             self_val.cmp(&other_val)
         }
     }
diff --git a/util/gen-types/src/extension/shortcut.rs b/util/gen-types/src/extension/shortcut.rs
index 499145ee90..6fcc732951 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].pack()
+        [u8::max_value(); 32].into()
     }
 
     /// 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.pack()
+        v.into()
     }
 }
 
@@ -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.pack()
+        inner.into()
     }
 
     /// 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.pack()
+        v.into()
     }
 }
 
@@ -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.pack())
+            .index(index.into())
             .build()
     }
 
     /// Creates a new null `OutPoint`.
     pub fn null() -> Self {
         packed::OutPoint::new_builder()
-            .index(u32::max_value().pack())
+            .index(u32::max_value().into())
             .build()
     }
 
     /// Checks whether self is a null `OutPoint`.
     pub fn is_null(&self) -> bool {
-        self.tx_hash().is_zero() && Unpack::<u32>::unpack(&self.index()) == u32::max_value()
+        self.tx_hash().is_zero() && Into::<u32>::into(self.index().as_reader()) == 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().unpack();
+        let index: u32 = self.index().as_reader().into();
         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.pack())
+            .since(block_number.into())
             .previous_output(previous_output)
             .build()
     }
@@ -110,7 +110,7 @@ impl packed::Script {
             .lock(self)
             .build()
             .as_bytes()
-            .pack()
+            .into()
     }
 
     /// Converts from bytes of [`CellbaseWitness`](struct.CellbaseWitness.html).
diff --git a/util/gen-types/src/generated/blockchain.rs b/util/gen-types/src/generated/blockchain.rs
index 3eb5b9b6b9..e9dae42fab 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.7.5
+// Generated by Molecule 0.8.0
 
 use molecule::prelude::*;
 #[derive(Clone)]
@@ -143,6 +143,7 @@ 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 {
@@ -204,6 +205,54 @@ 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 {
@@ -379,6 +428,7 @@ 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 {
@@ -464,6 +514,63 @@ 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 {
@@ -695,6 +802,7 @@ 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 {
@@ -828,6 +936,71 @@ 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 {
@@ -1174,6 +1347,7 @@ 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 {
@@ -1403,6 +1577,87 @@ 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 {
@@ -1749,6 +2004,7 @@ 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 {
@@ -1978,6 +2234,87 @@ 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 {
@@ -2151,7 +2488,7 @@ impl<'r> molecule::prelude::Reader<'r> for BytesReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BytesBuilder(pub(crate) Vec<Byte>);
 impl BytesBuilder {
     pub const ITEM_SIZE: usize = 1;
@@ -2164,9 +2501,7 @@ impl BytesBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Byte>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Byte) -> Option<Byte> {
@@ -2221,6 +2556,30 @@ 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 {
@@ -2355,7 +2714,7 @@ impl<'r> molecule::prelude::Reader<'r> for BytesOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BytesOptBuilder(pub(crate) Option<Bytes>);
 impl BytesOptBuilder {
     pub fn set(mut self, v: Option<Bytes>) -> Self {
@@ -2385,6 +2744,11 @@ 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 {
@@ -2608,7 +2972,7 @@ impl<'r> molecule::prelude::Reader<'r> for BytesOptVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BytesOptVecBuilder(pub(crate) Vec<BytesOpt>);
 impl BytesOptVecBuilder {
     pub fn set(mut self, v: Vec<BytesOpt>) -> Self {
@@ -2620,9 +2984,7 @@ impl BytesOptVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = BytesOpt>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: BytesOpt) -> Option<BytesOpt> {
@@ -2725,6 +3087,16 @@ 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 {
@@ -2948,7 +3320,7 @@ impl<'r> molecule::prelude::Reader<'r> for BytesVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BytesVecBuilder(pub(crate) Vec<Bytes>);
 impl BytesVecBuilder {
     pub fn set(mut self, v: Vec<Bytes>) -> Self {
@@ -2960,9 +3332,7 @@ impl BytesVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Bytes>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Bytes) -> Option<Bytes> {
@@ -3065,6 +3435,16 @@ 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 {
@@ -3244,7 +3624,7 @@ impl<'r> molecule::prelude::Reader<'r> for Byte32VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Byte32VecBuilder(pub(crate) Vec<Byte32>);
 impl Byte32VecBuilder {
     pub const ITEM_SIZE: usize = 32;
@@ -3257,9 +3637,7 @@ impl Byte32VecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Byte32>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Byte32) -> Option<Byte32> {
@@ -3337,6 +3715,16 @@ 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 {
@@ -3471,7 +3859,7 @@ impl<'r> molecule::prelude::Reader<'r> for ScriptOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct ScriptOptBuilder(pub(crate) Option<Script>);
 impl ScriptOptBuilder {
     pub fn set(mut self, v: Option<Script>) -> Self {
@@ -3501,6 +3889,11 @@ 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 {
@@ -3690,6 +4083,7 @@ 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 {
@@ -3787,6 +4181,65 @@ 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 {
@@ -4010,7 +4463,7 @@ impl<'r> molecule::prelude::Reader<'r> for UncleBlockVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct UncleBlockVecBuilder(pub(crate) Vec<UncleBlock>);
 impl UncleBlockVecBuilder {
     pub fn set(mut self, v: Vec<UncleBlock>) -> Self {
@@ -4022,9 +4475,7 @@ impl UncleBlockVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = UncleBlock>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: UncleBlock) -> Option<UncleBlock> {
@@ -4127,6 +4578,16 @@ 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 {
@@ -4350,7 +4811,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct TransactionVecBuilder(pub(crate) Vec<Transaction>);
 impl TransactionVecBuilder {
     pub fn set(mut self, v: Vec<Transaction>) -> Self {
@@ -4362,9 +4823,7 @@ impl TransactionVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Transaction>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Transaction) -> Option<Transaction> {
@@ -4467,6 +4926,16 @@ 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 {
@@ -4646,7 +5115,7 @@ impl<'r> molecule::prelude::Reader<'r> for ProposalShortIdVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct ProposalShortIdVecBuilder(pub(crate) Vec<ProposalShortId>);
 impl ProposalShortIdVecBuilder {
     pub const ITEM_SIZE: usize = 10;
@@ -4662,9 +5131,7 @@ impl ProposalShortIdVecBuilder {
         mut self,
         iter: T,
     ) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: ProposalShortId) -> Option<ProposalShortId> {
@@ -4742,6 +5209,16 @@ 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 {
@@ -4921,7 +5398,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellDepVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellDepVecBuilder(pub(crate) Vec<CellDep>);
 impl CellDepVecBuilder {
     pub const ITEM_SIZE: usize = 37;
@@ -4934,9 +5411,7 @@ impl CellDepVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellDep>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: CellDep) -> Option<CellDep> {
@@ -5014,6 +5489,16 @@ 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 {
@@ -5193,7 +5678,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellInputVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellInputVecBuilder(pub(crate) Vec<CellInput>);
 impl CellInputVecBuilder {
     pub const ITEM_SIZE: usize = 44;
@@ -5206,9 +5691,7 @@ impl CellInputVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellInput>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: CellInput) -> Option<CellInput> {
@@ -5286,6 +5769,16 @@ 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 {
@@ -5509,7 +6002,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellOutputVecBuilder(pub(crate) Vec<CellOutput>);
 impl CellOutputVecBuilder {
     pub fn set(mut self, v: Vec<CellOutput>) -> Self {
@@ -5521,9 +6014,7 @@ impl CellOutputVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellOutput>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: CellOutput) -> Option<CellOutput> {
@@ -5626,6 +6117,16 @@ 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 {
@@ -5859,7 +6360,7 @@ impl<'r> molecule::prelude::Reader<'r> for ScriptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct ScriptBuilder {
     pub(crate) code_hash: Byte32,
     pub(crate) hash_type: Byte,
@@ -6045,7 +6546,7 @@ impl<'r> molecule::prelude::Reader<'r> for OutPointReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct OutPointBuilder {
     pub(crate) tx_hash: Byte32,
     pub(crate) index: Uint32,
@@ -6212,7 +6713,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellInputReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellInputBuilder {
     pub(crate) since: Uint64,
     pub(crate) previous_output: OutPoint,
@@ -6482,7 +6983,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellOutputBuilder {
     pub(crate) capacity: Uint64,
     pub(crate) lock: Script,
@@ -6668,7 +7169,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellDepReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellDepBuilder {
     pub(crate) out_point: OutPoint,
     pub(crate) dep_type: Byte,
@@ -6985,7 +7486,7 @@ impl<'r> molecule::prelude::Reader<'r> for RawTransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RawTransactionBuilder {
     pub(crate) version: Uint32,
     pub(crate) cell_deps: CellDepVec,
@@ -7285,7 +7786,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct TransactionBuilder {
     pub(crate) raw: RawTransaction,
     pub(crate) witnesses: BytesVec,
@@ -7539,7 +8040,7 @@ impl<'r> molecule::prelude::Reader<'r> for RawHeaderReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RawHeaderBuilder {
     pub(crate) version: Uint32,
     pub(crate) compact_target: Uint32,
@@ -7757,7 +8258,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct HeaderBuilder {
     pub(crate) raw: RawHeader,
     pub(crate) nonce: Uint128,
@@ -8016,7 +8517,7 @@ impl<'r> molecule::prelude::Reader<'r> for UncleBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct UncleBlockBuilder {
     pub(crate) header: Header,
     pub(crate) proposals: ProposalShortIdVec,
@@ -8318,7 +8819,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockBuilder {
     pub(crate) header: Header,
     pub(crate) uncles: UncleBlockVec,
@@ -8654,7 +9155,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockV1Builder {
     pub(crate) header: Header,
     pub(crate) uncles: UncleBlockVec,
@@ -8945,7 +9446,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellbaseWitnessReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellbaseWitnessBuilder {
     pub(crate) lock: Script,
     pub(crate) message: Bytes,
@@ -9221,7 +9722,7 @@ impl<'r> molecule::prelude::Reader<'r> for WitnessArgsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct WitnessArgsBuilder {
     pub(crate) lock: BytesOpt,
     pub(crate) input_type: BytesOpt,
diff --git a/util/gen-types/src/generated/extensions.rs b/util/gen-types/src/generated/extensions.rs
index c9066a2cc1..a8c3ca21b1 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.7.5
+// Generated by Molecule 0.8.0
 
 use super::blockchain::*;
 use molecule::prelude::*;
@@ -136,7 +136,7 @@ impl<'r> molecule::prelude::Reader<'r> for BoolOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BoolOptBuilder(pub(crate) Option<Bool>);
 impl BoolOptBuilder {
     pub fn set(mut self, v: Option<Bool>) -> Self {
@@ -166,6 +166,11 @@ 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 {
@@ -300,7 +305,7 @@ impl<'r> molecule::prelude::Reader<'r> for Byte32OptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Byte32OptBuilder(pub(crate) Option<Byte32>);
 impl Byte32OptBuilder {
     pub fn set(mut self, v: Option<Byte32>) -> Self {
@@ -330,6 +335,11 @@ 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 {
@@ -454,6 +464,7 @@ 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 {
@@ -495,6 +506,54 @@ 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 {
@@ -637,6 +696,7 @@ 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 {
@@ -698,6 +758,54 @@ 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 {
@@ -873,6 +981,7 @@ 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 {
@@ -958,6 +1067,63 @@ 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 {
@@ -1137,7 +1303,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint32VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Uint32VecBuilder(pub(crate) Vec<Uint32>);
 impl Uint32VecBuilder {
     pub const ITEM_SIZE: usize = 4;
@@ -1150,9 +1316,7 @@ impl Uint32VecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint32>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Uint32) -> Option<Uint32> {
@@ -1230,6 +1394,16 @@ 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 {
@@ -1409,7 +1583,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint64VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Uint64VecBuilder(pub(crate) Vec<Uint64>);
 impl Uint64VecBuilder {
     pub const ITEM_SIZE: usize = 8;
@@ -1422,9 +1596,7 @@ impl Uint64VecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint64>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Uint64) -> Option<Uint64> {
@@ -1502,6 +1674,16 @@ 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 {
@@ -1681,7 +1863,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint256VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Uint256VecBuilder(pub(crate) Vec<Uint256>);
 impl Uint256VecBuilder {
     pub const ITEM_SIZE: usize = 32;
@@ -1694,9 +1876,7 @@ impl Uint256VecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint256>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Uint256) -> Option<Uint256> {
@@ -1774,6 +1954,16 @@ 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 {
@@ -1908,7 +2098,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellOutputOptBuilder(pub(crate) Option<CellOutput>);
 impl CellOutputOptBuilder {
     pub fn set(mut self, v: Option<CellOutput>) -> Self {
@@ -1938,6 +2128,11 @@ 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 {
@@ -2117,7 +2312,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct HeaderVecBuilder(pub(crate) Vec<Header>);
 impl HeaderVecBuilder {
     pub const ITEM_SIZE: usize = 208;
@@ -2130,9 +2325,7 @@ impl HeaderVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Header>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Header) -> Option<Header> {
@@ -2210,6 +2403,16 @@ 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 {
@@ -2389,7 +2592,7 @@ impl<'r> molecule::prelude::Reader<'r> for OutPointVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct OutPointVecBuilder(pub(crate) Vec<OutPoint>);
 impl OutPointVecBuilder {
     pub const ITEM_SIZE: usize = 36;
@@ -2402,9 +2605,7 @@ impl OutPointVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = OutPoint>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: OutPoint) -> Option<OutPoint> {
@@ -2482,6 +2683,16 @@ 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 {
@@ -2616,7 +2827,7 @@ impl<'r> molecule::prelude::Reader<'r> for Uint64VecOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Uint64VecOptBuilder(pub(crate) Option<Uint64Vec>);
 impl Uint64VecOptBuilder {
     pub fn set(mut self, v: Option<Uint64Vec>) -> Self {
@@ -2646,6 +2857,11 @@ 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 {
@@ -2871,7 +3087,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderDigestReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct HeaderDigestBuilder {
     pub(crate) children_hash: Byte32,
     pub(crate) total_difficulty: Uint256,
@@ -3090,7 +3306,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderViewReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct HeaderViewBuilder {
     pub(crate) hash: Byte32,
     pub(crate) data: Header,
@@ -3340,7 +3556,7 @@ impl<'r> molecule::prelude::Reader<'r> for UncleBlockVecViewReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct UncleBlockVecViewBuilder {
     pub(crate) hashes: Byte32Vec,
     pub(crate) data: UncleBlockVec,
@@ -3623,7 +3839,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionViewReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct TransactionViewBuilder {
     pub(crate) hash: Byte32,
     pub(crate) witness_hash: Byte32,
@@ -3954,7 +4170,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockExtReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockExtBuilder {
     pub(crate) total_difficulty: Uint256,
     pub(crate) total_uncles_count: Uint64,
@@ -4335,7 +4551,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockExtV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockExtV1Builder {
     pub(crate) total_difficulty: Uint256,
     pub(crate) total_uncles_count: Uint64,
@@ -4633,7 +4849,7 @@ impl<'r> molecule::prelude::Reader<'r> for EpochExtReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct EpochExtBuilder {
     pub(crate) previous_epoch_hash_rate: Uint256,
     pub(crate) last_block_hash_in_previous_epoch: Byte32,
@@ -4836,7 +5052,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionKeyReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct TransactionKeyBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) index: BeUint32,
@@ -5003,7 +5219,7 @@ impl<'r> molecule::prelude::Reader<'r> for NumberHashReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct NumberHashBuilder {
     pub(crate) number: Uint64,
     pub(crate) block_hash: Byte32,
@@ -5179,7 +5395,7 @@ impl<'r> molecule::prelude::Reader<'r> for TransactionInfoReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct TransactionInfoBuilder {
     pub(crate) block_number: Uint64,
     pub(crate) block_epoch: Uint64,
@@ -5506,7 +5722,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellEntryReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellEntryBuilder {
     pub(crate) output: CellOutput,
     pub(crate) block_hash: Byte32,
@@ -5805,7 +6021,7 @@ impl<'r> molecule::prelude::Reader<'r> for CellDataEntryReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CellDataEntryBuilder {
     pub(crate) output_data: Bytes,
     pub(crate) output_data_hash: Byte32,
@@ -6016,7 +6232,7 @@ impl<'r> molecule::prelude::Reader<'r> for RelayMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RelayMessageBuilder(pub(crate) RelayMessageUnion);
 impl RelayMessageBuilder {
     pub const ITEMS_COUNT: usize = 8;
@@ -6378,6 +6594,46 @@ 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 {
@@ -6660,7 +6916,7 @@ impl<'r> molecule::prelude::Reader<'r> for CompactBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CompactBlockBuilder {
     pub(crate) header: Header,
     pub(crate) short_ids: ProposalShortIdVec,
@@ -7031,7 +7287,7 @@ impl<'r> molecule::prelude::Reader<'r> for CompactBlockV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct CompactBlockV1Builder {
     pub(crate) header: Header,
     pub(crate) short_ids: ProposalShortIdVec,
@@ -7332,7 +7588,7 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RelayTransactionBuilder {
     pub(crate) cycles: Uint64,
     pub(crate) transaction: Transaction,
@@ -7601,7 +7857,7 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RelayTransactionVecBuilder(pub(crate) Vec<RelayTransaction>);
 impl RelayTransactionVecBuilder {
     pub fn set(mut self, v: Vec<RelayTransaction>) -> Self {
@@ -7616,9 +7872,7 @@ impl RelayTransactionVecBuilder {
         mut self,
         iter: T,
     ) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: RelayTransaction) -> Option<RelayTransaction> {
@@ -7725,6 +7979,16 @@ 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 {
@@ -7922,7 +8186,7 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RelayTransactionsBuilder {
     pub(crate) transactions: RelayTransactionVec,
 }
@@ -8155,7 +8419,7 @@ impl<'r> molecule::prelude::Reader<'r> for RelayTransactionHashesReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RelayTransactionHashesBuilder {
     pub(crate) tx_hashes: Byte32Vec,
 }
@@ -8388,7 +8652,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetRelayTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetRelayTransactionsBuilder {
     pub(crate) tx_hashes: Byte32Vec,
 }
@@ -8657,7 +8921,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlockTransactionsBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) indexes: Uint32Vec,
@@ -8945,7 +9209,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockTransactionsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockTransactionsBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) transactions: TransactionVec,
@@ -9217,7 +9481,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockProposalReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlockProposalBuilder {
     pub(crate) block_hash: Byte32,
     pub(crate) proposals: ProposalShortIdVec,
@@ -9460,7 +9724,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockProposalReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockProposalBuilder {
     pub(crate) transactions: TransactionVec,
 }
@@ -9714,7 +9978,7 @@ impl<'r> molecule::prelude::Reader<'r> for IndexTransactionReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct IndexTransactionBuilder {
     pub(crate) index: Uint32,
     pub(crate) transaction: Transaction,
@@ -9983,7 +10247,7 @@ impl<'r> molecule::prelude::Reader<'r> for IndexTransactionVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct IndexTransactionVecBuilder(pub(crate) Vec<IndexTransaction>);
 impl IndexTransactionVecBuilder {
     pub fn set(mut self, v: Vec<IndexTransaction>) -> Self {
@@ -9998,9 +10262,7 @@ impl IndexTransactionVecBuilder {
         mut self,
         iter: T,
     ) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: IndexTransaction) -> Option<IndexTransaction> {
@@ -10107,6 +10369,16 @@ 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 {
@@ -10256,7 +10528,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFilterMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockFilterMessageBuilder(pub(crate) BlockFilterMessageUnion);
 impl BlockFilterMessageBuilder {
     pub const ITEMS_COUNT: usize = 6;
@@ -10574,6 +10846,36 @@ 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 {
@@ -10692,7 +10994,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockFiltersReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlockFiltersBuilder {
     pub(crate) start_number: Uint64,
 }
@@ -10955,7 +11257,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFiltersReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockFiltersBuilder {
     pub(crate) start_number: Uint64,
     pub(crate) block_hashes: Byte32Vec,
@@ -11128,7 +11430,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockFilterHashesReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlockFilterHashesBuilder {
     pub(crate) start_number: Uint64,
 }
@@ -11412,7 +11714,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFilterHashesReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockFilterHashesBuilder {
     pub(crate) start_number: Uint64,
     pub(crate) parent_block_filter_hash: Byte32,
@@ -11586,7 +11888,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlockFilterCheckPointsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlockFilterCheckPointsBuilder {
     pub(crate) start_number: Uint64,
 }
@@ -11842,7 +12144,7 @@ impl<'r> molecule::prelude::Reader<'r> for BlockFilterCheckPointsReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct BlockFilterCheckPointsBuilder {
     pub(crate) start_number: Uint64,
     pub(crate) block_filter_hashes: Byte32Vec,
@@ -12037,7 +12339,7 @@ impl<'r> molecule::prelude::Reader<'r> for SyncMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SyncMessageBuilder(pub(crate) SyncMessageUnion);
 impl SyncMessageBuilder {
     pub const ITEMS_COUNT: usize = 5;
@@ -12279,6 +12581,31 @@ 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 {
@@ -12506,7 +12833,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetHeadersReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetHeadersBuilder {
     pub(crate) hash_stop: Byte32,
     pub(crate) block_locator_hashes: Byte32Vec,
@@ -12749,7 +13076,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlocksReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlocksBuilder {
     pub(crate) block_hashes: Byte32Vec,
 }
@@ -12982,7 +13309,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendHeadersReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendHeadersBuilder {
     pub(crate) headers: HeaderVec,
 }
@@ -13225,7 +13552,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendBlockBuilder {
     pub(crate) block: Block,
 }
@@ -13518,7 +13845,7 @@ impl<'r> molecule::prelude::Reader<'r> for FilteredBlockReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct FilteredBlockBuilder {
     pub(crate) header: Header,
     pub(crate) witnesses_root: Byte32,
@@ -13798,7 +14125,7 @@ impl<'r> molecule::prelude::Reader<'r> for MerkleProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct MerkleProofBuilder {
     pub(crate) indices: Uint32Vec,
     pub(crate) lemmas: Byte32Vec,
@@ -13997,7 +14324,7 @@ impl<'r> molecule::prelude::Reader<'r> for InIBDReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct InIBDBuilder {}
 impl InIBDBuilder {
     pub const FIELD_COUNT: usize = 0;
@@ -14200,7 +14527,7 @@ impl<'r> molecule::prelude::Reader<'r> for HeaderDigestVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct HeaderDigestVecBuilder(pub(crate) Vec<HeaderDigest>);
 impl HeaderDigestVecBuilder {
     pub const ITEM_SIZE: usize = 120;
@@ -14213,9 +14540,7 @@ impl HeaderDigestVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = HeaderDigest>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: HeaderDigest) -> Option<HeaderDigest> {
@@ -14293,6 +14618,16 @@ 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 {
@@ -14553,7 +14888,7 @@ impl<'r> molecule::prelude::Reader<'r> for VerifiableHeaderReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct VerifiableHeaderBuilder {
     pub(crate) header: Header,
     pub(crate) uncles_hash: Byte32,
@@ -14840,7 +15175,7 @@ impl<'r> molecule::prelude::Reader<'r> for VerifiableHeaderVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct VerifiableHeaderVecBuilder(pub(crate) Vec<VerifiableHeader>);
 impl VerifiableHeaderVecBuilder {
     pub fn set(mut self, v: Vec<VerifiableHeader>) -> Self {
@@ -14855,9 +15190,7 @@ impl VerifiableHeaderVecBuilder {
         mut self,
         iter: T,
     ) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: VerifiableHeader) -> Option<VerifiableHeader> {
@@ -14964,6 +15297,16 @@ 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 {
@@ -15187,7 +15530,7 @@ impl<'r> molecule::prelude::Reader<'r> for FilteredBlockVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct FilteredBlockVecBuilder(pub(crate) Vec<FilteredBlock>);
 impl FilteredBlockVecBuilder {
     pub fn set(mut self, v: Vec<FilteredBlock>) -> Self {
@@ -15199,9 +15542,7 @@ impl FilteredBlockVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = FilteredBlock>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: FilteredBlock) -> Option<FilteredBlock> {
@@ -15304,6 +15645,16 @@ 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 {
@@ -15459,7 +15810,7 @@ impl<'r> molecule::prelude::Reader<'r> for LightClientMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct LightClientMessageBuilder(pub(crate) LightClientMessageUnion);
 impl LightClientMessageBuilder {
     pub const ITEMS_COUNT: usize = 8;
@@ -15813,6 +16164,46 @@ 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 {
@@ -16010,7 +16401,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetLastStateReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetLastStateBuilder {
     pub(crate) subscribe: Bool,
 }
@@ -16257,7 +16648,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendLastStateReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendLastStateBuilder {
     pub(crate) last_header: VerifiableHeader,
 }
@@ -16587,7 +16978,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetLastStateProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetLastStateProofBuilder {
     pub(crate) last_hash: Byte32,
     pub(crate) start_hash: Byte32,
@@ -16914,7 +17305,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendLastStateProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendLastStateProofBuilder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -17186,7 +17577,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetBlocksProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetBlocksProofBuilder {
     pub(crate) last_hash: Byte32,
     pub(crate) block_hashes: Byte32Vec,
@@ -17503,7 +17894,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendBlocksProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendBlocksProofBuilder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -17881,7 +18272,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendBlocksProofV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendBlocksProofV1Builder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -18180,7 +18571,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetTransactionsProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetTransactionsProofBuilder {
     pub(crate) last_hash: Byte32,
     pub(crate) tx_hashes: Byte32Vec,
@@ -18487,7 +18878,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendTransactionsProofReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendTransactionsProofBuilder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -18855,7 +19246,7 @@ impl<'r> molecule::prelude::Reader<'r> for SendTransactionsProofV1Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct SendTransactionsProofV1Builder {
     pub(crate) last_header: VerifiableHeader,
     pub(crate) proof: HeaderDigestVec,
@@ -19134,7 +19525,7 @@ impl<'r> molecule::prelude::Reader<'r> for TimeReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct TimeBuilder {
     pub(crate) timestamp: Uint64,
 }
@@ -19467,7 +19858,7 @@ impl<'r> molecule::prelude::Reader<'r> for RawAlertReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct RawAlertBuilder {
     pub(crate) notice_until: Uint64,
     pub(crate) id: Uint32,
@@ -19776,7 +20167,7 @@ impl<'r> molecule::prelude::Reader<'r> for AlertReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct AlertBuilder {
     pub(crate) raw: RawAlert,
     pub(crate) signatures: BytesVec,
@@ -20055,7 +20446,7 @@ impl<'r> molecule::prelude::Reader<'r> for IdentifyReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct IdentifyBuilder {
     pub(crate) flag: Uint64,
     pub(crate) name: Bytes,
diff --git a/util/gen-types/src/generated/protocols.rs b/util/gen-types/src/generated/protocols.rs
index 030d4e6b48..97b1370233 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.7.5
+// Generated by Molecule 0.8.0
 
 use super::blockchain::*;
 use super::extensions::*;
@@ -140,7 +140,7 @@ impl<'r> molecule::prelude::Reader<'r> for PingPayloadReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PingPayloadBuilder(pub(crate) PingPayloadUnion);
 impl PingPayloadBuilder {
     pub const ITEMS_COUNT: usize = 2;
@@ -298,6 +298,16 @@ 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 {
@@ -497,7 +507,7 @@ impl<'r> molecule::prelude::Reader<'r> for PingMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PingMessageBuilder {
     pub(crate) payload: PingPayload,
 }
@@ -730,7 +740,7 @@ impl<'r> molecule::prelude::Reader<'r> for PingReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PingBuilder {
     pub(crate) nonce: Uint32,
 }
@@ -963,7 +973,7 @@ impl<'r> molecule::prelude::Reader<'r> for PongReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PongBuilder {
     pub(crate) nonce: Uint32,
 }
@@ -1222,7 +1232,7 @@ impl<'r> molecule::prelude::Reader<'r> for NodeVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct NodeVecBuilder(pub(crate) Vec<Node>);
 impl NodeVecBuilder {
     pub fn set(mut self, v: Vec<Node>) -> Self {
@@ -1234,9 +1244,7 @@ impl NodeVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Node>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Node) -> Option<Node> {
@@ -1339,6 +1347,16 @@ 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 {
@@ -1562,7 +1580,7 @@ impl<'r> molecule::prelude::Reader<'r> for Node2VecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Node2VecBuilder(pub(crate) Vec<Node2>);
 impl Node2VecBuilder {
     pub fn set(mut self, v: Vec<Node2>) -> Self {
@@ -1574,9 +1592,7 @@ impl Node2VecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Node2>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Node2) -> Option<Node2> {
@@ -1679,6 +1695,16 @@ 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 {
@@ -1809,6 +1835,7 @@ 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 {
@@ -1855,6 +1882,54 @@ 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 {
@@ -1989,7 +2064,7 @@ impl<'r> molecule::prelude::Reader<'r> for PortOptReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct PortOptBuilder(pub(crate) Option<Uint16>);
 impl PortOptBuilder {
     pub fn set(mut self, v: Option<Uint16>) -> Self {
@@ -2019,6 +2094,11 @@ 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 {
@@ -2158,7 +2238,7 @@ impl<'r> molecule::prelude::Reader<'r> for DiscoveryPayloadReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct DiscoveryPayloadBuilder(pub(crate) DiscoveryPayloadUnion);
 impl DiscoveryPayloadBuilder {
     pub const ITEMS_COUNT: usize = 2;
@@ -2316,6 +2396,16 @@ 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 {
@@ -2516,7 +2606,7 @@ impl<'r> molecule::prelude::Reader<'r> for DiscoveryMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct DiscoveryMessageBuilder {
     pub(crate) payload: DiscoveryPayload,
 }
@@ -2784,7 +2874,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetNodesReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetNodesBuilder {
     pub(crate) version: Uint32,
     pub(crate) count: Uint32,
@@ -3088,7 +3178,7 @@ impl<'r> molecule::prelude::Reader<'r> for GetNodes2Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct GetNodes2Builder {
     pub(crate) version: Uint32,
     pub(crate) count: Uint32,
@@ -3366,7 +3456,7 @@ impl<'r> molecule::prelude::Reader<'r> for NodesReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct NodesBuilder {
     pub(crate) announce: Bool,
     pub(crate) items: NodeVec,
@@ -3626,7 +3716,7 @@ impl<'r> molecule::prelude::Reader<'r> for Nodes2Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Nodes2Builder {
     pub(crate) announce: Bool,
     pub(crate) items: Node2Vec,
@@ -3869,7 +3959,7 @@ impl<'r> molecule::prelude::Reader<'r> for NodeReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct NodeBuilder {
     pub(crate) addresses: BytesVec,
 }
@@ -4121,7 +4211,7 @@ impl<'r> molecule::prelude::Reader<'r> for Node2Reader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Node2Builder {
     pub(crate) addresses: BytesVec,
     pub(crate) flags: Uint64,
@@ -4390,7 +4480,7 @@ impl<'r> molecule::prelude::Reader<'r> for AddressVecReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct AddressVecBuilder(pub(crate) Vec<Address>);
 impl AddressVecBuilder {
     pub fn set(mut self, v: Vec<Address>) -> Self {
@@ -4402,9 +4492,7 @@ impl AddressVecBuilder {
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Address>>(mut self, iter: T) -> Self {
-        for elem in iter {
-            self.0.push(elem);
-        }
+        self.0.extend(iter);
         self
     }
     pub fn replace(&mut self, index: usize, v: Address) -> Option<Address> {
@@ -4507,6 +4595,16 @@ 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 {
@@ -4704,7 +4802,7 @@ impl<'r> molecule::prelude::Reader<'r> for AddressReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct AddressBuilder {
     pub(crate) bytes: Bytes,
 }
@@ -4973,7 +5071,7 @@ impl<'r> molecule::prelude::Reader<'r> for IdentifyMessageReader<'r> {
         Ok(())
     }
 }
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct IdentifyMessageBuilder {
     pub(crate) listen_addrs: AddressVec,
     pub(crate) observed_addr: Address,

From 76f90b4d62399568b7e5b0111d10ea18a7a729aa Mon Sep 17 00:00:00 2001
From: driftluo <driftluo@foxmail.com>
Date: Tue, 9 Jul 2024 16:58:39 +0800
Subject: [PATCH 2/3] feat: remove all pack/unpack used

---
 Makefile                                      |   2 +-
 benches/benches/benchmarks/overall.rs         |  14 +-
 benches/benches/benchmarks/resolve.rs         |  10 +-
 benches/benches/benchmarks/util.rs            |  70 ++--
 block-filter/src/filter.rs                    |   5 +-
 chain/src/tests/basic.rs                      |  40 +-
 chain/src/tests/block_assembler.rs            |  22 +-
 chain/src/tests/cell.rs                       |  24 +-
 chain/src/tests/delay_verify.rs               |  61 ++-
 chain/src/tests/dep_cell.rs                   |  54 +--
 chain/src/tests/find_fork.rs                  |  44 +--
 chain/src/tests/load_code_with_snapshot.rs    |  34 +-
 chain/src/tests/load_input_cell_data.rs       |  12 +-
 chain/src/tests/load_input_data_hash_cell.rs  |  12 +-
 .../tests/non_contextual_block_txs_verify.rs  |  24 +-
 chain/src/tests/reward.rs                     |  28 +-
 chain/src/tests/util.rs                       |   6 +-
 ckb-bin/src/subcommand/init.rs                |   4 +-
 ckb-bin/src/subcommand/list_hashes.rs         |  18 +-
 miner/src/miner.rs                            |   5 +-
 network/src/protocols/discovery/protocol.rs   |  12 +-
 network/src/protocols/identify/mod.rs         |   8 +-
 pow/src/eaglesong.rs                          |   7 +-
 pow/src/eaglesong_blake2b.rs                  |   7 +-
 pow/src/tests.rs                              |   3 +-
 rpc/src/module/alert.rs                       |   2 +-
 rpc/src/module/chain.rs                       |  67 ++--
 rpc/src/module/experiment.rs                  |  12 +-
 rpc/src/module/miner.rs                       |   6 +-
 rpc/src/module/net.rs                         |  13 +-
 rpc/src/module/pool.rs                        |   6 +-
 rpc/src/module/stats.rs                       |   3 +-
 rpc/src/module/test.rs                        |  10 +-
 rpc/src/tests/examples.rs                     |   6 +-
 rpc/src/tests/mod.rs                          |  11 +-
 rpc/src/tests/module/miner.rs                 |   4 +-
 rpc/src/tests/module/pool.rs                  |   6 +-
 rpc/src/tests/setup.rs                        |  24 +-
 script/fuzz/fuzz_targets/syscall_exec.rs      |  20 +-
 .../transaction_scripts_verifier_data0.rs     |  16 +-
 .../transaction_scripts_verifier_data1.rs     |  16 +-
 .../transaction_scripts_verifier_data2.rs     |  16 +-
 script/src/syscalls/load_cell.rs              |   2 +-
 script/src/syscalls/load_input.rs             |   2 +-
 script/src/syscalls/tests/utils.rs            |   2 +-
 .../syscalls/tests/vm_latest/syscalls_1.rs    |  56 +--
 .../syscalls/tests/vm_latest/syscalls_2.rs    |   4 +-
 script/src/verify.rs                          |   6 +-
 .../tests/ckb_latest/features_since_v2019.rs  | 210 +++++-----
 .../tests/ckb_latest/features_since_v2021.rs  | 124 +++---
 .../tests/ckb_latest/features_since_v2023.rs  | 373 +++++++++++++++++-
 script/src/verify/tests/utils.rs              |  46 +--
 shared/src/shared.rs                          |  18 +-
 spec/src/consensus.rs                         |  18 +-
 spec/src/lib.rs                               |  52 +--
 spec/src/tests/consensus.rs                   |   5 +-
 spec/src/tests/mod.rs                         |  14 +-
 spec/src/tests/versionbits.rs                 |  16 +-
 store/src/cell.rs                             |  26 +-
 store/src/store.rs                            |  47 +--
 store/src/tests/db.rs                         |  12 +-
 store/src/transaction.rs                      |  42 +-
 store/src/write_batch.rs                      |   4 +-
 .../get_block_filter_check_points_process.rs  |   6 +-
 .../filter/get_block_filter_hashes_process.rs |   6 +-
 sync/src/filter/get_block_filters_process.rs  |   8 +-
 sync/src/net_time_checker.rs                  |   4 +-
 .../src/relayer/block_transactions_process.rs |   4 +-
 sync/src/relayer/compact_block_process.rs     |   6 +-
 sync/src/relayer/compact_block_verifier.rs    |  10 +-
 .../src/relayer/get_block_proposal_process.rs |   2 +-
 .../relayer/get_block_transactions_process.rs |  21 +-
 sync/src/relayer/get_transactions_process.rs  |   2 +-
 sync/src/relayer/mod.rs                       |  29 +-
 .../relayer/tests/block_proposal_process.rs   |  34 +-
 .../tests/block_transactions_process.rs       |  60 +--
 .../tests/block_transactions_verifier.rs      |  14 +-
 sync/src/relayer/tests/compact_block.rs       |   8 +-
 .../relayer/tests/compact_block_process.rs    |  32 +-
 .../relayer/tests/compact_block_verifier.rs   |  54 ++-
 .../tests/get_block_proposal_process.rs       |   2 +-
 .../relayer/tests/get_transactions_process.rs |   2 +-
 sync/src/relayer/tests/helper.rs              |  36 +-
 sync/src/relayer/tests/reconstruct_block.rs   |  22 +-
 sync/src/relayer/transactions_process.rs      |   7 +-
 sync/src/synchronizer/get_headers_process.rs  |   8 +-
 sync/src/synchronizer/mod.rs                  |   6 +-
 sync/src/tests/inflight_blocks.rs             |  93 +++--
 sync/src/tests/orphan_block_pool.rs           | 152 +++++++
 sync/src/tests/sync_shared.rs                 |   6 +-
 sync/src/tests/synchronizer/basic_sync.rs     |  20 +-
 sync/src/tests/synchronizer/functions.rs      |  42 +-
 sync/src/tests/types.rs                       |   5 +-
 sync/src/tests/util.rs                        |  10 +-
 sync/src/types/mod.rs                         |   2 +-
 test/src/assertion/reward_assertion.rs        |   3 +-
 test/src/node.rs                              |   8 +-
 test/src/rpc.rs                               |  38 +-
 test/src/specs/alert/alert_propagation.rs     |  20 +-
 .../specs/consensus/insufficient_reward.rs    |   2 +-
 test/src/specs/dao/dao_tx.rs                  |   8 +-
 test/src/specs/dao/dao_user.rs                |  26 +-
 test/src/specs/dao/dao_verifier.rs            |  17 +-
 test/src/specs/dao/satoshi_dao_occupied.rs    |  12 +-
 test/src/specs/hardfork/v2021/cell_deps.rs    |  39 +-
 .../specs/hardfork/v2021/vm_b_extension.rs    |   8 +-
 test/src/specs/hardfork/v2021/vm_version1.rs  |   8 +-
 test/src/specs/hardfork/v2023/vm_version2.rs  |   8 +-
 test/src/specs/mining/basic.rs                |   7 +-
 test/src/specs/mining/bootstrap.rs            |   4 +-
 test/src/specs/mining/fee.rs                  |   8 +-
 test/src/specs/mining/proposal.rs             |   3 +-
 test/src/specs/mining/uncle.rs                |   7 +-
 test/src/specs/relay/block_relay.rs           |   3 +-
 test/src/specs/relay/compact_block.rs         |  10 +-
 .../specs/relay/get_block_proposal_process.rs |   2 +-
 .../relay/get_block_transactions_process.rs   |   8 +-
 test/src/specs/relay/transaction_relay.rs     |   2 +-
 test/src/specs/rpc/get_block_template.rs      |   6 +-
 test/src/specs/rpc/submit_block.rs            |  13 +-
 test/src/specs/rpc/transaction_proof.rs       |   3 +-
 test/src/specs/sync/block_filter.rs           |  20 +-
 test/src/specs/sync/block_sync.rs             |  10 +-
 test/src/specs/sync/chain_forks.rs            |  12 +-
 test/src/specs/sync/invalid_locator_size.rs   |   4 +-
 test/src/specs/tx_pool/collision.rs           |   2 +-
 .../tx_pool/different_txs_with_same_input.rs  |   2 +-
 test/src/specs/tx_pool/mod.rs                 |   4 +-
 test/src/specs/tx_pool/orphan_tx.rs           |   6 +-
 test/src/specs/tx_pool/pool_reconcile.rs      |   4 +-
 test/src/specs/tx_pool/replace.rs             |  71 ++--
 .../src/specs/tx_pool/send_defected_binary.rs |  12 +-
 .../src/specs/tx_pool/send_large_cycles_tx.rs |  14 +-
 .../src/specs/tx_pool/send_low_fee_rate_tx.rs |   4 +-
 .../specs/tx_pool/send_multisig_secp_tx.rs    |  10 +-
 test/src/specs/tx_pool/send_secp_tx.rs        |  29 +-
 test/src/txo.rs                               |  14 +-
 test/src/util/cell.rs                         |   2 +-
 test/src/util/mining.rs                       |   2 +-
 test/src/util/transaction.rs                  |   6 +-
 test/src/utils.rs                             |  40 +-
 tx-pool/src/block_assembler/mod.rs            |  44 ++-
 tx-pool/src/block_assembler/tests.rs          |  11 +-
 tx-pool/src/component/pool_map.rs             |   3 +-
 tx-pool/src/component/tests/pending.rs        |  76 ++--
 tx-pool/src/component/tests/proposed.rs       |  46 +--
 tx-pool/src/component/tests/score_key.rs      |  16 +-
 tx-pool/src/component/tests/util.rs           |  12 +-
 util/dao/src/lib.rs                           |  21 +-
 util/dao/src/tests.rs                         |  50 +--
 util/dao/utils/src/lib.rs                     |   7 +-
 util/fixed-hash/core/src/std_str.rs           |   2 +-
 .../src/conversion/blockchain/mod.rs          |  24 +-
 .../src/conversion/blockchain/std_env.rs      |  18 +-
 util/gen-types/src/conversion/primitive.rs    |  60 +--
 util/gen-types/src/conversion/utilities.rs    |  20 +-
 util/gen-types/src/generated/mod.rs           |   2 +
 util/indexer-sync/src/lib.rs                  |   5 +-
 util/indexer/src/indexer.rs                   | 344 ++++++++--------
 util/indexer/src/service.rs                   | 130 +++---
 util/jsonrpc-types/src/alert.rs               |  36 +-
 util/jsonrpc-types/src/block_template.rs      |  28 +-
 util/jsonrpc-types/src/blockchain.rs          | 198 +++++++---
 util/jsonrpc-types/src/bytes.rs               |   4 +-
 util/jsonrpc-types/src/cell.rs                |   3 +-
 util/jsonrpc-types/src/pool.rs                |   6 +-
 util/jsonrpc-types/src/proposal_short_id.rs   |   2 +-
 util/jsonrpc-types/src/tests/blockchain.rs    |  14 +-
 util/jsonrpc-types/src/uints.rs               |  25 ++
 util/launcher/Cargo.toml                      |   6 +-
 util/launcher/src/lib.rs                      |   3 +-
 .../src/components/get_blocks_proof.rs        |  10 +-
 .../src/components/get_last_state.rs          |   2 +-
 .../src/components/get_last_state_proof.rs    |  12 +-
 .../src/components/get_transactions_proof.rs  |  12 +-
 util/light-client-protocol-server/src/lib.rs  |   6 +-
 .../src/tests/components/get_blocks_proof.rs  |   4 +-
 .../tests/components/get_last_state_proof.rs  |   8 +-
 .../components/get_transactions_proof.rs      |   4 +-
 .../src/tests/prelude.rs                      |   2 +-
 .../src/tests/utils/chain.rs                  |  12 +-
 .../src/migrations/add_number_hash_mapping.rs |   4 +-
 util/migrate/src/migrations/cell.rs           |  12 +-
 .../migrations/set_2019_block_cycle_zero.rs   |   6 +-
 util/migrate/src/tests.rs                     |  16 +-
 util/network-alert/src/alert_relayer.rs       |   4 +-
 util/network-alert/src/notifier.rs            |  14 +-
 .../src/tests/generate_alert_signature.rs     |  38 +-
 util/network-alert/src/tests/test_notifier.rs |  10 +-
 util/network-alert/src/tests/test_verifier.rs |   6 +-
 util/reward-calculator/src/tests.rs           |  49 ++-
 util/rich-indexer/src/indexer/insert.rs       |  20 +-
 util/rich-indexer/src/indexer/mod.rs          |   7 +-
 .../async_indexer_handle/get_cells.rs         |  20 +-
 .../get_cells_capacity.rs                     |   5 +-
 util/rich-indexer/src/tests/insert.rs         |  96 ++---
 util/rich-indexer/src/tests/query.rs          | 168 ++++----
 util/test-chain-utils/src/chain.rs            |  14 +-
 util/test-chain-utils/src/median_time.rs      |   7 +-
 util/test-chain-utils/src/mock_chain.rs       |  45 ++-
 util/test-chain-utils/src/mock_store.rs       |   7 +-
 util/test-chain-utils/src/mock_utils.rs       |  20 +-
 util/types/src/conversion/blockchain.rs       |  19 +
 util/types/src/conversion/storage.rs          | 198 ++++++++++
 util/types/src/conversion/utilities.rs        |  16 +
 .../src/contextual_block_verifier.rs          |   2 +-
 .../src/tests/contextual_block_verifier.rs    |  42 +-
 .../contextual/src/tests/uncle_verifier.rs    |  18 +-
 verification/src/tests/block_verifier.rs      |  36 +-
 verification/src/tests/genesis_verifier.rs    |  10 +-
 verification/src/tests/header_verifier.rs     |  19 +-
 verification/src/tests/mod.rs                 |  13 +-
 .../src/tests/transaction_verifier.rs         | 146 +++----
 verification/src/transaction_verifier.rs      |   5 +-
 214 files changed, 3207 insertions(+), 2270 deletions(-)
 create mode 100644 sync/src/tests/orphan_block_pool.rs

diff --git a/Makefile b/Makefile
index 91ef1c2a5d..e9ef3cd9dd 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 .DEFAULT_GOAL:=help
 SHELL = /bin/sh
 MOLC    := moleculec
-MOLC_VERSION := 0.7.5
+MOLC_VERSION := 0.8.0
 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 103cab0893..10c6876d3e 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().unpack());
+    let args = JsonBytes::from_bytes(secp_script.args().into());
     let hash_type = ScriptHashType::try_from(secp_script.hash_type()).expect("checked data");
 
     BlockAssemblerConfig {
-        code_hash: secp_script.code_hash().unpack(),
+        code_hash: secp_script.code_hash().into(),
         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).pack())
+                .capacity(capacity_bytes!(50_000).into())
                 .lock(secp_script.clone())
                 .build();
             TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(output.clone())
                 .output(output)
-                .output_data(data.pack())
-                .output_data(data.pack())
+                .output_data(data.clone().into())
+                .output_data(data.into())
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .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>().pack())
+                                .nonce(random::<u128>().into())
                                 .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 37ec9d11c3..8fa587210c 100644
--- a/benches/benches/benchmarks/resolve.rs
+++ b/benches/benches/benchmarks/resolve.rs
@@ -33,8 +33,8 @@ const DEFAULT_CODE_HASH: H256 =
 
 fn script() -> Script {
     Script::new_builder()
-        .code_hash(DEFAULT_CODE_HASH.pack())
-        .args(Bytes::from(PUBKEY_HASH.as_bytes()).pack())
+        .code_hash(DEFAULT_CODE_HASH.into())
+        .args(Bytes::from(PUBKEY_HASH.as_bytes()).into())
         .hash_type(ScriptHashType::Type.into())
         .build()
 }
@@ -43,7 +43,7 @@ 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.pack())
+        .index(0u32.into())
         .build();
 
     CellDep::new_builder()
@@ -54,11 +54,11 @@ fn cell_dep(genesis: &BlockView) -> CellDep {
 
 fn block_assembler_config() -> BlockAssemblerConfig {
     let secp_script = script();
-    let args = JsonBytes::from_bytes(secp_script.args().unpack());
+    let args = JsonBytes::from_bytes(secp_script.args().into());
     let hash_type = ScriptHashType::try_from(secp_script.hash_type()).expect("checked data");
 
     BlockAssemblerConfig {
-        code_hash: secp_script.code_hash().unpack(),
+        code_hash: secp_script.code_hash().into(),
         hash_type: hash_type.into(),
         args,
         message: Default::default(),
diff --git a/benches/benches/benchmarks/util.rs b/benches/benches/benchmarks/util.rs
index a9f64d0a50..ba93d6c2f2 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).pack())
+                        .capacity(capacity_bytes!(50_000).into())
                         .lock(always_success_script.clone())
                         .build(),
                 )
-                .output_data(data.pack())
+                .output_data(data.into())
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
         .dao(dao)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .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.pack())
+        .output_data(always_success_cell_data.into())
         .build()
 }
 
@@ -110,11 +110,11 @@ pub fn create_always_success_cellbase(shared: &Shared, parent: &HeaderView) -> T
         builder
             .output(
                 CellOutput::new_builder()
-                    .capacity(capacity.pack())
+                    .capacity(capacity.into())
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .build()
     }
 }
@@ -185,11 +185,11 @@ pub fn gen_always_success_block(
         .transactions(transactions)
         .proposals(proposals)
         .parent_hash(p_block.hash())
-        .number(number.pack())
-        .timestamp(timestamp.pack())
-        .compact_target(epoch.compact_target().pack())
-        .epoch(epoch.number_with_fraction(number).pack())
-        .nonce(random::<u128>().pack())
+        .number(number.into())
+        .timestamp(timestamp.into())
+        .compact_target(epoch.compact_target().into())
+        .epoch(epoch.number_with_fraction(number).into())
+        .nonce(random::<u128>().into())
         .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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build();
         (cell, data)
     };
@@ -219,12 +219,12 @@ lazy_static! {
         let data: Bytes = raw_data.to_vec().into();
 
         let cell = CellOutput::new_builder()
-            .capacity(Capacity::bytes(data.len()).unwrap().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build();
 
         let script = Script::new_builder()
             .code_hash(CellOutput::calc_data_hash(&data))
-            .args(Bytes::from(PUBKEY_HASH.as_bytes()).pack())
+            .args(Bytes::from(PUBKEY_HASH.as_bytes()).into())
             .hash_type(ScriptHashType::Data.into())
             .build();
 
@@ -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.pack(), secp_cell_data.pack()];
+    let outputs_data = vec![secp_data_cell_data.into(), secp_cell_data.into()];
     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).pack())
+                .capacity(capacity_bytes!(50_000).into())
                 .lock(secp_script.clone())
                 .build();
             TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(output.clone())
                 .output(output)
-                .output_data(data.pack())
-                .output_data(data.pack())
+                .output_data((&data).into())
+                .output_data(data.into())
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .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.pack())
+                    .capacity(capacity.into())
                     .lock(secp_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .build()
     }
 }
@@ -395,11 +395,11 @@ pub fn gen_secp_block(
         .transactions(transactions)
         .proposals(proposals)
         .parent_hash(p_block.hash())
-        .number(number.pack())
-        .timestamp(timestamp.pack())
-        .compact_target(epoch.compact_target().pack())
-        .epoch(epoch.number_with_fraction(number).pack())
-        .nonce(random::<u128>().pack())
+        .number(number.into())
+        .timestamp(timestamp.into())
+        .compact_target(epoch.compact_target().into())
+        .epoch(epoch.number_with_fraction(number).into())
+        .nonce(random::<u128>().into())
         .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).pack())
+                .capacity(capacity_bytes!(50_000).into())
                 .lock(lock)
                 .build(),
         )
-        .output_data(data.pack())
+        .output_data(data.into())
         .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).pack())
+        .capacity(capacity_bytes!(50_000).into())
         .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.pack())
-        .output_data(data.pack())
+        .output_data((&data).into())
+        .output_data(data.into())
         .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])).pack())
+        .lock(Some(Bytes::from(vec![0u8; 65])).into())
         .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).pack()).build();
+    let witness = witness.as_builder().lock(Some(sig).into()).build();
 
-    let mut witnesses = vec![witness.as_bytes().pack()];
-    witnesses.extend(non_sig_witnesses.into_iter().map(|w| w.pack()));
+    let mut witnesses = vec![witness.as_bytes().into()];
+    witnesses.extend(non_sig_witnesses.into_iter().map(|w| w.into()));
 
     raw.as_advanced_builder().set_witnesses(witnesses).build()
 }
diff --git a/block-filter/src/filter.rs b/block-filter/src/filter.rs
index 3c8a217557..4b00522e49 100644
--- a/block-filter/src/filter.rs
+++ b/block-filter/src/filter.rs
@@ -6,7 +6,6 @@ use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
     core::HeaderView,
     packed::{Byte32, CellOutput, OutPoint},
-    prelude::*,
     utilities::{build_filter_data, FilterDataProvider},
 };
 
@@ -26,7 +25,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().unpack()))
+            .and_then(|(tx, _)| tx.outputs().get(out_point.index().into()))
     }
 }
 
@@ -153,7 +152,7 @@ impl BlockFilter {
         db_transaction
             .insert_block_filter(
                 &header.hash(),
-                &filter_data.pack(),
+                &filter_data.as_slice().into(),
                 &parent_block_filter_hash,
             )
             .expect("insert_block_filter should be ok");
diff --git a/chain/src/tests/basic.rs b/chain/src/tests/basic.rs
index b1d2947a82..ae69ec9cfd 100644
--- a/chain/src/tests/basic.rs
+++ b/chain/src/tests/basic.rs
@@ -10,7 +10,6 @@ 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::{
@@ -22,6 +21,7 @@ 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;
 
@@ -119,11 +119,13 @@ fn test_genesis_transaction_spend() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000).pack())
+                .capacity(capacity_bytes!(100_000_000).into())
                 .build();
             100
         ])
-        .outputs_data(vec![Bytes::new(); 100].pack())
+        .outputs_data(Into::<packed::BytesVec>::into(
+            vec![Bytes::new(); 100].as_slice(),
+        ))
         .build();
     let always_success_tx = create_always_success_tx();
 
@@ -136,7 +138,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)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .dao(dao)
         .build();
 
@@ -429,12 +431,14 @@ fn test_genesis_transaction_fetch() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000).pack())
+                .capacity(capacity_bytes!(100_000_000).into())
                 .lock(Script::default())
                 .build();
             100
         ])
-        .outputs_data(vec![Bytes::new(); 100].pack())
+        .outputs_data(Into::<packed::BytesVec>::into(
+            vec![Bytes::new(); 100].as_slice(),
+        ))
         .build();
 
     let dao = genesis_dao_data(vec![&tx]).unwrap();
@@ -442,7 +446,7 @@ fn test_genesis_transaction_fetch() {
     let genesis_block = BlockBuilder::default()
         .dao(dao)
         .transaction(tx)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .build();
 
     let consensus = ConsensusBuilder::default()
@@ -574,10 +578,10 @@ fn prepare_context_chain(
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .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())
+            .number((parent.number() + 1).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .timestamp((parent.timestamp() + timestep).into())
+            .compact_target(epoch.compact_target().into())
             .transactions(transactions)
             .dao(dao)
             .build();
@@ -614,10 +618,10 @@ fn prepare_context_chain(
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
             .uncles(uncles)
-            .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())
+            .number((parent.number() + 1).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .timestamp((parent.timestamp() + timestep).into())
+            .compact_target(epoch.compact_target().into())
             .transactions(transactions)
             .dao(dao)
             .build();
@@ -640,7 +644,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)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .transaction(cellbase)
         .dao(dao)
         .build();
@@ -733,7 +737,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)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .transaction(cellbase)
         .dao(dao)
         .build();
@@ -787,7 +791,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)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .transaction(cellbase)
         .dao(dao)
         .build();
diff --git a/chain/src/tests/block_assembler.rs b/chain/src/tests/block_assembler.rs
index caf0eb84ca..3748d67936 100644
--- a/chain/src/tests/block_assembler.rs
+++ b/chain/src/tests/block_assembler.rs
@@ -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).pack())
-        .number(number.pack())
-        .epoch(epoch.number_with_fraction(number).pack())
-        .compact_target(epoch.compact_target().pack())
-        .nonce(nonce.pack())
+        .timestamp((parent_header.timestamp() + 10).into())
+        .number(number.into())
+        .epoch(epoch.number_with_fraction(number).into())
+        .compact_target(epoch.compact_target().into())
+        .nonce(nonce.into())
         .dao(dao)
         .build();
 
     BlockBuilder::default()
         .header(header)
         .transaction(cellbase)
-        .proposal([1; 10].pack())
+        .proposal([1; 10].into())
         .build_unchecked()
 }
 
@@ -124,7 +124,7 @@ fn create_cellbase(number: BlockNumber, epoch: &EpochExt) -> TransactionView {
         .input(CellInput::new_cellbase_input(number))
         .output(
             CellOutput::new_builder()
-                .capacity(epoch.block_reward(number).unwrap().pack())
+                .capacity(epoch.block_reward(number).unwrap().into())
                 .build(),
         )
         .output_data(Default::default())
@@ -234,7 +234,7 @@ fn test_prepare_uncles() {
             .unwrap()
             .unwrap()
     }
-    assert_eq!(block_template.uncles[0].hash, block0_0.hash().unpack());
+    assert_eq!(block_template.uncles[0].hash, block0_0.hash().into());
 
     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().unpack());
+    assert_eq!(block_template.uncles[0].hash, block0_0.hash().into());
 
     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.pack())
+                        .capacity(per_output_capacity.into())
                         .build()
                 })
                 .collect::<Vec<CellOutput>>(),
         )
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
         .build()
 }
 
diff --git a/chain/src/tests/cell.rs b/chain/src/tests/cell.rs
index 3d9c2fd5b9..74efb94358 100644
--- a/chain/src/tests/cell.rs
+++ b/chain/src/tests/cell.rs
@@ -37,10 +37,10 @@ pub(crate) fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity.pack())
+                    .capacity(capacity.into())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .build()
     }
 }
@@ -66,10 +66,10 @@ pub(crate) fn gen_block(
 
     let block = BlockBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp((parent_header.timestamp() + 20_000).pack())
-        .number(number.pack())
-        .compact_target(epoch.compact_target().pack())
-        .epoch(epoch.number_with_fraction(number).pack())
+        .timestamp((parent_header.timestamp() + 20_000).into())
+        .number(number.into())
+        .compact_target(epoch.compact_target().into())
+        .epoch(epoch.number_with_fraction(number).into())
         .transactions(txs)
         .build();
 
@@ -83,16 +83,16 @@ pub(crate) fn create_transaction(parent: &TransactionView, index: u32) -> Transa
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .unpack();
+        .into();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
                 .build(),
         )
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build()
 }
 
@@ -104,11 +104,11 @@ fn test_block_cells_update() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -116,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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/delay_verify.rs b/chain/src/tests/delay_verify.rs
index bd36fa558f..88f57bf650 100644
--- a/chain/src/tests/delay_verify.rs
+++ b/chain/src/tests/delay_verify.rs
@@ -6,7 +6,6 @@ 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;
@@ -287,9 +286,9 @@ fn test_full_dead_transaction() {
 
     let block = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .compact_target((compact_target - 1).pack())
+        .number((parent.number() + 1).into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .compact_target((compact_target - 1).into())
         .dao(dao)
         .transaction(cellbase_tx)
         .build();
@@ -327,9 +326,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number((parent.number() + 1).pack())
-                    .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                    .compact_target((compact_target - 1).pack())
+                    .number((parent.number() + 1).into())
+                    .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                    .compact_target((compact_target - 1).into())
                     .dao(dao)
                     .transactions(transactions)
                     .proposals(vec![tx1.proposal_short_id()])
@@ -348,9 +347,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number((parent.number() + 1).pack())
-                    .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                    .compact_target((compact_target - 1).pack())
+                    .number((parent.number() + 1).into())
+                    .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                    .compact_target((compact_target - 1).into())
                     .dao(dao)
                     .transactions(transactions)
                     .build()
@@ -365,9 +364,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number((parent.number() + 1).pack())
-                    .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                    .compact_target((compact_target - 1).pack())
+                    .number((parent.number() + 1).into())
+                    .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                    .compact_target((compact_target - 1).into())
                     .dao(dao)
                     .transactions(transactions)
                     .build()
@@ -407,9 +406,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).pack())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                        .compact_target((compact_target - 1).pack())
+                        .number((parent.number() + 1).into())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                        .compact_target((compact_target - 1).into())
                         .dao(dao)
                         .transactions(transactions)
                         .proposals(vec![tx2.proposal_short_id(), tx3.proposal_short_id()])
@@ -429,9 +428,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).pack())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                        .compact_target((compact_target - 1).pack())
+                        .number((parent.number() + 1).into())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                        .compact_target((compact_target - 1).into())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -448,9 +447,9 @@ fn test_full_dead_transaction() {
 
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).pack())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                        .compact_target((compact_target - 1).pack())
+                        .number((parent.number() + 1).into())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                        .compact_target((compact_target - 1).into())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -479,9 +478,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).pack())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                        .compact_target((compact_target - 1).pack())
+                        .number((parent.number() + 1).into())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                        .compact_target((compact_target - 1).into())
                         .dao(dao)
                         .proposals(vec![tx2.proposal_short_id(), tx3.proposal_short_id()])
                         .transactions(transactions)
@@ -501,9 +500,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).pack())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                        .compact_target((compact_target - 1).pack())
+                        .number((parent.number() + 1).into())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                        .compact_target((compact_target - 1).into())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -520,9 +519,9 @@ fn test_full_dead_transaction() {
 
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).pack())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-                        .compact_target((compact_target - 1).pack())
+                        .number((parent.number() + 1).into())
+                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+                        .compact_target((compact_target - 1).into())
                         .dao(dao)
                         .transactions(transactions)
                         .build()
diff --git a/chain/src/tests/dep_cell.rs b/chain/src/tests/dep_cell.rs
index 64e3fbe7d4..6b88d0b476 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().unpack();
+            let cap: Capacity = output.capacity().into();
             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.pack())
+                        .capacity(per_output_capacity.into())
                         .lock(always_success_script.clone())
                         .build()
                 })
                 .collect::<Vec<CellOutput>>(),
         )
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
-        .output_data(Bytes::new().pack())
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
+        .output_data(Bytes::new().into())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
-        .output_data(Bytes::new().pack())
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
+        .output_data(Bytes::new().into())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/find_fork.rs b/chain/src/tests/find_fork.rs
index 2c39cfd0ca..78af9bfb97 100644
--- a/chain/src/tests/find_fork.rs
+++ b/chain/src/tests/find_fork.rs
@@ -9,9 +9,7 @@ use ckb_systemtime::unix_time_as_millis;
 use ckb_test_chain_utils::{MockChain, MockStore};
 use ckb_types::{
     core::{BlockBuilder, BlockExt, BlockView},
-    packed,
-    prelude::Pack,
-    U256,
+    packed, U256,
 };
 use ckb_verification_traits::Switch;
 use dashmap::DashSet;
@@ -431,10 +429,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block1 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).pack())
-        .compact_target(parent.compact_target().pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .nonce(1u128.pack())
+        .number((parent.number() + 1).into())
+        .compact_target(parent.compact_target().into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .nonce(1u128.into())
         .uncle(uncle)
         .build();
     chain_controller
@@ -450,10 +448,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block2 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).pack())
-        .compact_target(parent.compact_target().pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .nonce(2u128.pack())
+        .number((parent.number() + 1).into())
+        .compact_target(parent.compact_target().into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .nonce(2u128.into())
         .build();
     parent = new_block2.clone();
     chain_controller
@@ -466,10 +464,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block3 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).pack())
-        .compact_target(parent.compact_target().pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .nonce(2u128.pack())
+        .number((parent.number() + 1).into())
+        .compact_target(parent.compact_target().into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .nonce(2u128.into())
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block3), Switch::DISABLE_ALL)
@@ -484,10 +482,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block4 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).pack())
-        .compact_target(parent.compact_target().pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .nonce(1u128.pack())
+        .number((parent.number() + 1).into())
+        .compact_target(parent.compact_target().into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .nonce(1u128.into())
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block4.clone()), Switch::DISABLE_ALL)
@@ -501,10 +499,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block5 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).pack())
-        .compact_target(parent.compact_target().pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .nonce(1u128.pack())
+        .number((parent.number() + 1).into())
+        .compact_target(parent.compact_target().into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .nonce(1u128.into())
         .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 9a51e6e82b..24c50a955f 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.pack())
+        .output_data(load_is_even_data.into())
         .output(is_even_lib_cell.clone())
-        .output_data(is_even_lib_data.pack())
+        .output_data(is_even_lib_data.into())
         .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()
-        .unpack();
+        .into();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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,7 +69,7 @@ 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.pack()
+        vec.as_slice().into()
     };
 
     let lock_script = Script::new_builder()
@@ -82,11 +82,11 @@ fn test_load_code() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
@@ -130,7 +130,7 @@ 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.pack()
+        vec.as_slice().into()
     };
 
     let lock_script = Script::new_builder()
@@ -143,11 +143,11 @@ fn test_load_code_with_snapshot() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
@@ -209,7 +209,7 @@ 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.pack()
+        vec.as_slice().into()
     };
 
     let lock_script = Script::new_builder()
@@ -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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/load_input_cell_data.rs b/chain/src/tests/load_input_cell_data.rs
index 236a952325..67e15590b2 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()
-        .unpack();
+        .into();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
                 .lock(load_input_one_byte_script.clone())
                 .build(),
         )
-        .output_data(Bytes::from(b"1".to_vec()).pack())
+        .output_data(Bytes::from(b"1".to_vec()).into())
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(load_input_one_byte_script.clone())
                 .build(),
         )
-        .output_data(Bytes::from(b"1".to_vec()).pack())
+        .output_data(Bytes::from(b"1".to_vec()).into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .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 b753c1d91f..f445dd2d19 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()
-        .unpack();
+        .into();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
                 .lock(load_input_data_hash_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(load_input_data_hash_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .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 68178658d8..41af7bf1a5 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.pack())
+                    .capacity(capacity.into())
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .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).pack())
-        .number(number.pack())
-        .compact_target(epoch.compact_target().pack())
-        .epoch(epoch.number_with_fraction(number).pack())
+        .timestamp((parent_header.timestamp() + 20_000).into())
+        .number(number.into())
+        .compact_target(epoch.compact_target().into())
+        .epoch(epoch.number_with_fraction(number).into())
         .transactions(txs)
         .build();
 
@@ -96,12 +96,12 @@ pub(crate) fn create_transaction(
         .get(0)
         .expect("get output index 0")
         .capacity()
-        .unpack();
+        .into();
 
     let mut builder = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
                 .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().pack())
+        builder = builder.output_data(Bytes::new().into())
     }
     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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/reward.rs b/chain/src/tests/reward.rs
index 876a1495bf..a9dc168194 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).pack())
+                    .capacity(reward.unwrap_or(capacity).into())
                     .lock(reward_lock)
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .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).pack())
-        .number(number.pack())
-        .compact_target(epoch.compact_target().pack())
-        .epoch(epoch.number_with_fraction(number).pack())
+        .timestamp((parent_header.timestamp() + 20_000).into())
+        .number(number.into())
+        .compact_target(epoch.compact_target().into())
+        .epoch(epoch.number_with_fraction(number).into())
         .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()
-        .unpack();
+        .into();
 
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().pack())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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).pack())
+                .capacity(capacity_bytes!(5_000).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .compact_target(DIFF_TWO.into())
         .dao(dao)
         .build();
 
@@ -176,7 +176,7 @@ 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()).pack();
+    let bob_args: packed::Bytes = Bytes::from(b"b0b".to_vec()).into();
 
     let bob = ScriptBuilder::default()
         .args(bob_args)
@@ -184,7 +184,7 @@ fn finalize_reward() {
         .hash_type(ScriptHashType::Data.into())
         .build();
 
-    let alice_args: packed::Bytes = Bytes::from(b"a11ce".to_vec()).pack();
+    let alice_args: packed::Bytes = Bytes::from(b"a11ce".to_vec()).into();
     let alice = ScriptBuilder::default()
         .args(alice_args)
         .code_hash(always_success_script.code_hash())
diff --git a/chain/src/tests/util.rs b/chain/src/tests/util.rs
index f29cd97ad7..fae0de4d81 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).pack())
+                            .capacity(capacity_bytes!(50_000).into())
                             .lock(always_success_script.clone())
                             .build(),
                     )
-                    .output_data(data.pack())
+                    .output_data(data.into())
                     .build()
             })
             .collect();
 
         let genesis_block = BlockBuilder::default()
             .dao(dao)
-            .compact_target(DIFF_TWO.pack())
+            .compact_target(DIFF_TWO.into())
             .transaction(tx)
             .transactions(transactions)
             .build();
diff --git a/ckb-bin/src/subcommand/init.rs b/ckb-bin/src/subcommand/init.rs
index 2cdcc13b26..36a076c91d 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::{prelude::*, H256};
+use ckb_types::H256;
 
 const DEFAULT_LOCK_SCRIPT_HASH_TYPE: &str = "type";
 const SECP256K1_BLAKE160_SIGHASH_ALL_ARG_LEN: usize = 20 * 2 + 2; // 42 = 20 x 2 + prefix 0x
@@ -79,7 +79,7 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
                     .build_consensus()
                     .expect("Build consensus failed")
                     .get_secp_type_script_hash()
-                    .unpack();
+                    .into();
                 format!("{hash:#x}")
             });
 
diff --git a/ckb-bin/src/subcommand/list_hashes.rs b/ckb-bin/src/subcommand/list_hashes.rs
index 62e431c10b..cdff023aad 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::{cli, CKBAppConfig, ExitCode};
 use ckb_chain_spec::ChainSpec;
 use ckb_resource::{Resource, AVAILABLE_SPECS};
-use ckb_types::{packed::CellOutput, prelude::*, H256};
+use ckb_types::{packed::CellOutput, H256};
 use ckb_util::LinkedHashMap;
 use clap::ArgMatches;
 use serde::{Deserialize, Serialize};
@@ -39,7 +39,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().unpack();
+            let genesis_hash: H256 = consensus.genesis_hash().into();
             if hash != genesis_hash {
                 eprintln!(
                     "Genesis hash unmatched in {} chainspec config file:\n\
@@ -69,14 +69,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()).unpack();
+                let data_hash: H256 = CellOutput::calc_data_hash(&data.raw_data()).into();
                 let type_hash: Option<H256> = output
                     .type_()
                     .to_opt()
-                    .map(|script| script.calc_script_hash().unpack());
+                    .map(|script| script.calc_script_hash().into());
                 SystemCell {
                     path: resource.to_string(),
-                    tx_hash: cellbase.hash().unpack(),
+                    tx_hash: cellbase.hash().into(),
                     index: index_minus_one + 1,
                     data_hash,
                     type_hash,
@@ -95,15 +95,15 @@ impl TryFrom<ChainSpec> for SpecHashes {
                     .iter()
                     .map(|res| res.to_string())
                     .collect::<Vec<_>>(),
-                tx_hash: dep_group_tx.hash().unpack(),
+                tx_hash: dep_group_tx.hash().into(),
                 index,
             })
             .collect::<Vec<_>>();
 
         Ok(SpecHashes {
-            spec_hash: spec.hash.unpack(),
-            genesis: consensus.genesis_hash().unpack(),
-            cellbase: cellbase.hash().unpack(),
+            spec_hash: spec.hash.into(),
+            genesis: consensus.genesis_hash().into(),
+            cellbase: cellbase.hash().into(),
             system_cells: cells_hashes,
             dep_groups,
         })
diff --git a/miner/src/miner.rs b/miner/src/miner.rs
index 436ea53ca4..d600e760a4 100644
--- a/miner/src/miner.rs
+++ b/miner/src/miner.rs
@@ -116,8 +116,7 @@ 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().unpack());
+            let (target, _) = compact_to_target(work.block.header().raw().compact_target().into());
             self.notify_workers(WorkerMessage::NewWork {
                 pow_hash,
                 work,
@@ -131,7 +130,7 @@ impl Miner {
         let raw_header = work.block.header().raw();
         let header = Header::new_builder()
             .raw(raw_header)
-            .nonce(nonce.pack())
+            .nonce(nonce.into())
             .build();
         let block = work
             .block
diff --git a/network/src/protocols/discovery/protocol.rs b/network/src/protocols/discovery/protocol.rs
index 0950e48784..c5f16f025c 100644
--- a/network/src/protocols/discovery/protocol.rs
+++ b/network/src/protocols/discovery/protocol.rs
@@ -32,8 +32,8 @@ impl DiscoveryMessage {
                 listen_port,
                 required_flags,
             } => {
-                let version = version.pack();
-                let count = count.pack();
+                let version = version.into();
+                let count = count.into();
                 let listen_port = packed::PortOpt::new_builder()
                     .set(listen_port.map(|port| {
                         let port_le = port.to_le_bytes();
@@ -43,7 +43,7 @@ impl DiscoveryMessage {
                             .build()
                     }))
                     .build();
-                let required_flags = required_flags.bits().pack();
+                let required_flags = required_flags.bits().into();
                 let get_node = packed::GetNodes2::new_builder()
                     .listen_port(listen_port)
                     .count(count)
@@ -70,7 +70,7 @@ impl DiscoveryMessage {
                         )
                     }
                     let bytes_vec = packed::BytesVec::new_builder().set(vec_addrs).build();
-                    let flags = item.flags.bits().pack();
+                    let flags = item.flags.bits().into();
                     let node = packed::Node2::new_builder()
                         .addresses(bytes_vec)
                         .flags(flags)
@@ -118,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().unpack())
+                    Flags::from_bits_truncate(reader.required_flags().into())
                 } else {
                     Flags::COMPATIBILITY
                 };
@@ -146,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().unpack())
+                        Flags::from_bits_truncate(reader.flags().into())
                     } else {
                         Flags::COMPATIBILITY
                     };
diff --git a/network/src/protocols/identify/mod.rs b/network/src/protocols/identify/mod.rs
index 8f2448050d..0c3a0bb8f7 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().pack())
-                .flag(flags.bits().pack())
-                .client_version(client_version.as_str().pack())
+                .name(name.as_str().into())
+                .flag(flags.bits().into())
+                .client_version(client_version.as_str().into())
                 .build()
                 .as_bytes(),
             name,
@@ -613,7 +613,7 @@ impl Identify {
             return None;
         }
 
-        let flag: u64 = reader.flag().unpack();
+        let flag: u64 = reader.flag().into();
         if flag == 0 {
             return None;
         }
diff --git a/pow/src/eaglesong.rs b/pow/src/eaglesong.rs
index f7bb88be27..456f131945 100644
--- a/pow/src/eaglesong.rs
+++ b/pow/src/eaglesong.rs
@@ -9,12 +9,11 @@ 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().unpack());
+        let input = crate::pow_message(&header.as_reader().calc_pow_hash(), header.nonce().into());
         let mut output = [0u8; 32];
         eaglesong(&input, &mut output);
 
-        let (block_target, overflow) = compact_to_target(header.raw().compact_target().unpack());
+        let (block_target, overflow) = compact_to_target(header.raw().compact_target().into());
 
         if block_target.is_zero() || overflow {
             debug!(
@@ -43,7 +42,7 @@ impl PowEngine for EaglesongPowEngine {
                 );
                 debug!(
                     "PowEngine::verify error: nonce {:#x}",
-                    header.nonce().unpack()
+                    Into::<u128>::into(header.nonce())
                 );
                 debug!(
                     "PowEngine::verify error: pow input: 0x{:x}",
diff --git a/pow/src/eaglesong_blake2b.rs b/pow/src/eaglesong_blake2b.rs
index 0b87aed9ad..fbfbbd6df5 100644
--- a/pow/src/eaglesong_blake2b.rs
+++ b/pow/src/eaglesong_blake2b.rs
@@ -10,15 +10,14 @@ 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().unpack());
+        let input = crate::pow_message(&header.as_reader().calc_pow_hash(), header.nonce().into());
         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().unpack());
+        let (block_target, overflow) = compact_to_target(header.raw().compact_target().into());
 
         if block_target.is_zero() || overflow {
             debug!(
@@ -51,7 +50,7 @@ impl PowEngine for EaglesongBlake2bPowEngine {
                 );
                 debug!(
                     "PowEngine::verify error: nonce {:#x}",
-                    header.nonce().unpack()
+                    Into::<u128>::into(header.nonce())
                 );
                 debug!(
                     "PowEngine::verify error: pow input: 0x{:x}",
diff --git a/pow/src/tests.rs b/pow/src/tests.rs
index ad4f27ca26..fafeabd3dd 100644
--- a/pow/src/tests.rs
+++ b/pow/src/tests.rs
@@ -1,10 +1,9 @@
 use crate::pow_message;
 use ckb_hash::blake2b_256;
-use ckb_types::prelude::*;
 
 #[test]
 fn test_pow_message() {
-    let zero_hash = blake2b_256([]).pack();
+    let zero_hash = blake2b_256([]).into();
     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 959ea2e3ee..fe6a243a03 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().unpack();
+        let notice_until: u64 = alert.raw().notice_until().into();
         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 a82aabb77b..d6288a3876 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.pack();
+        let block_hash = block_hash.into();
 
         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.pack();
+        let block_hash = block_hash.into();
         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.pack();
+        let block_hash = block_hash.into();
         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.pack();
+        let tx_hash = tx_hash.into();
         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.unpack()))
+            .map(|h| h.into()))
     }
 
     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().pack(),
+            self.shared.snapshot().epoch_ext().into(),
         ))
     }
 
@@ -1817,7 +1817,7 @@ impl ChainRpc for ChainRpcImpl {
             .and_then(|hash| {
                 snapshot
                     .get_epoch_ext(&hash)
-                    .map(|ext| EpochView::from_ext(ext.pack()))
+                    .map(|ext| EpochView::from_ext(ext.into()))
             }))
     }
 
@@ -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.pack())
-        {
-            block_number
-        } else {
-            return Ok(None);
-        };
+        let block_number =
+            if let Some(block_number) = snapshot.get_block_number(&(&block_hash).into()) {
+                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.pack();
+        let block_hash = (&block_hash).into();
         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().unpack(),
-            witnesses_root: block.calc_witnesses_root().unpack(),
+            block_hash: block.hash().into(),
+            witnesses_root: block.calc_witnesses_root().into(),
             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.pack())
+            .get_block(&(&tx_proof.block_hash).into())
             .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.pack();
+                let witnesses_root = tx_proof.witnesses_root.into();
                 let merkle_proof = MerkleProof::new(
                     tx_proof
                         .proof
@@ -1956,7 +1956,7 @@ impl ChainRpc for ChainRpcImpl {
                         .proof
                         .lemmas
                         .into_iter()
-                        .map(|lemma| lemma.pack())
+                        .map(|lemma| lemma.into())
                         .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.unpack()).collect())
+                                    Some(tx_hashes.iter().map(|hash| hash.into()).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().unpack(),
+            block_hash: block.hash().into(),
             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.pack())
+            .get_block(&(&tx_proof.block_hash).into())
             .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.pack())
+                        .map(|lemma| lemma.into())
                         .collect(),
                 );
                 let witnesses_merkle_proof = MerkleProof::new(
@@ -2038,7 +2038,7 @@ impl ChainRpc for ChainRpcImpl {
                         .witnesses_proof
                         .lemmas
                         .into_iter()
-                        .map(|lemma| lemma.pack())
+                        .map(|lemma| lemma.into())
                         .collect(),
                 );
 
@@ -2055,12 +2055,7 @@ impl ChainRpc for ChainRpcImpl {
                                                 witnesses_proof_root,
                                             ])
                                         {
-                                            Some(
-                                                tx_hashes
-                                                    .iter()
-                                                    .map(|hash| hash.unpack())
-                                                    .collect(),
-                                            )
+                                            Some(tx_hashes.iter().map(|hash| hash.into()).collect())
                                         } else {
                                             None
                                         }
@@ -2080,7 +2075,7 @@ impl ChainRpc for ChainRpcImpl {
         verbosity: Option<Uint32>,
     ) -> Result<Option<ResponseFormat<BlockView>>> {
         let snapshot = self.shared.snapshot();
-        let block_hash = block_hash.pack();
+        let block_hash = block_hash.into();
         if snapshot.is_main_chain(&block_hash) {
             return Ok(None);
         }
@@ -2108,7 +2103,7 @@ impl ChainRpc for ChainRpcImpl {
     }
 
     fn get_block_median_time(&self, block_hash: H256) -> Result<Option<Timestamp>> {
-        let block_hash = block_hash.pack();
+        let block_hash = block_hash.into();
         let snapshot = self.shared.snapshot();
         if !snapshot.is_main_chain(&block_hash) {
             return Ok(None);
@@ -2160,7 +2155,7 @@ impl ChainRpcImpl {
             return Ok(TransactionWithStatus::with_committed(
                 None,
                 tx_info.block_number,
-                tx_info.block_hash.unpack(),
+                tx_info.block_hash.into(),
                 tx_info.index as u32,
                 cycles,
                 None,
@@ -2209,7 +2204,7 @@ impl ChainRpcImpl {
             return Ok(TransactionWithStatus::with_committed(
                 Some(tx),
                 tx_info.block_number,
-                tx_info.block_hash.unpack(),
+                tx_info.block_hash.into(),
                 tx_info.index as u32,
                 cycles,
                 None,
@@ -2296,7 +2291,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.pack()) {
+            match snapshot.get_transaction_info(&(&tx_hash).into()) {
                 Some(tx_info) => {
                     if retrieved_block_hash.is_none() {
                         retrieved_block_hash = Some(tx_info.block_hash);
@@ -2322,7 +2317,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.pack()) {
+            if !retrieved_block_hash.eq(&specified_block_hash.into()) {
                 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 90e910dc1a..fe768c3719 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, prelude::*};
+use ckb_types::{core, packed};
 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().unpack())
+                    .get(out_point.index().into())
                     .ok_or_else(|| RPCError::invalid_params("invalid out_point"))?;
                 let output_data = tx
                     .outputs_data()
-                    .get(out_point.index().unpack())
+                    .get(out_point.index().into())
                     .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.pack(),
+                    &withdrawing_header_hash.into(),
                 ) {
                     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().unpack())
+                    .get(withdrawing_out_point.index().into())
                     .ok_or_else(|| RPCError::invalid_params("invalid withdrawing_out_point"))?;
                 let output_data = withdrawing_tx
                     .outputs_data()
-                    .get(withdrawing_out_point.index().unpack())
+                    .get(withdrawing_out_point.index().into())
                     .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 3338c6d5aa..c1df3387ac 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().unpack());
+                        return Ok(header.hash().into());
                     }
                 }
             };
@@ -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(Pack::pack(&block.extension()))
+                .extension(block.extension().into())
                 .parent_chain_root(parent_chain_root)
                 .build();
             let light_client_message = {
@@ -367,7 +367,7 @@ impl MinerRpc for MinerRpcImpl {
             }
         }
 
-        Ok(header.hash().unpack())
+        Ok(header.hash().into())
     }
 }
 
diff --git a/rpc/src/module/net.rs b/rpc/src/module/net.rs
index de75699e68..54276a82e8 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::prelude::{Pack, Unpack};
+use ckb_types::packed;
 use jsonrpc_core::Result;
 use jsonrpc_utils::rpc;
 use std::sync::Arc;
@@ -740,13 +740,10 @@ 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: shared
-                .assume_valid_target_specified()
-                .as_ref()
-                .clone()
-                .unwrap_or_default()
-                .pack()
-                .into(),
+            assume_valid_target: Into::<packed::Byte32>::into(
+                state.assume_valid_target_specified().unwrap_or_default(),
+            )
+            .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(),
diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
index a9e65da1c3..21e239ca42 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.unpack()),
+            Ok(_) => Ok(tx_hash.into()),
             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.pack()).map_err(|e| {
+        tx_pool.remove_local_tx(tx_hash.into()).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.pack())
+            .get_tx_detail(tx_hash.into())
             .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 0dececa47f..8df7056955 100644
--- a/rpc/src/module/stats.rs
+++ b/rpc/src/module/stats.rs
@@ -3,7 +3,6 @@ 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;
@@ -179,7 +178,7 @@ impl StatsRpc for StatsRpcImpl {
             .collect();
 
         Ok(DeploymentsInfo {
-            hash: snapshot.tip_hash().unpack(),
+            hash: snapshot.tip_hash().into(),
             epoch: snapshot.tip_header().epoch().number().into(),
             deployments,
         })
diff --git a/rpc/src/module/test.rs b/rpc/src/module/test.rs
index 1974b39404..2e2c20707d 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().unpack()))
+            Ok(Some(block.hash().into()))
         } 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.pack())
+                .get_block_header(&target_tip_hash.into())
                 .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.unpack())
+        Ok(tx_hash.into())
     }
 
     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.pack())
+            .get_block_header(&(&block_template.parent_hash).into())
             .expect("parent header should be stored");
         let mut seen_inputs = HashSet::new();
 
@@ -825,6 +825,6 @@ impl IntegrationTestRpcImpl {
             error!("Broadcast new block failed: {:?}", err);
         }
 
-        Ok(block_view.header().hash().unpack())
+        Ok(block_view.header().hash().into())
     }
 }
diff --git a/rpc/src/tests/examples.rs b/rpc/src/tests/examples.rs
index 03afbb9d3c..0e33e0ac9e 100644
--- a/rpc/src/tests/examples.rs
+++ b/rpc/src/tests/examples.rs
@@ -102,10 +102,10 @@ fn collect_code_block(
 }
 
 fn construct_example_transaction() -> TransactionView {
-    let previous_output = OutPoint::new(EXAMPLE_TX_PARENT.clone().pack(), 0);
+    let previous_output = OutPoint::new(EXAMPLE_TX_PARENT.clone().into(), 0);
     let input = CellInput::new(previous_output, 0);
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(always_success_cell().2.clone())
         .build();
     let cell_dep = CellDep::new_builder()
@@ -278,7 +278,7 @@ impl RpcTestSuite {
         let example_tx = construct_example_transaction();
         assert_eq!(
             EXAMPLE_TX_HASH,
-            example_tx.hash().unpack(),
+            example_tx.hash().into(),
             "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 59a2191b1b..71c54689a7 100644
--- a/rpc/src/tests/mod.rs
+++ b/rpc/src/tests/mod.rs
@@ -11,7 +11,6 @@ use ckb_types::{
         TransactionView,
     },
     packed::{CellInput, OutPoint},
-    prelude::*,
 };
 use reqwest::blocking::Client;
 use serde::{Deserialize, Serialize};
@@ -199,10 +198,10 @@ fn next_block(shared: &Shared, parent: &HeaderView) -> BlockView {
     BlockBuilder::default()
         .transaction(cellbase)
         .parent_hash(parent.hash())
-        .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())
+        .number((parent.number() + 1).into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .timestamp((parent.timestamp() + 1).into())
+        .compact_target(epoch.compact_target().into())
         .dao(dao)
         .build()
 }
@@ -216,7 +215,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.to_owned().pack())
+        .output_data(always_success_cell_data.to_owned().into())
         .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 42f9bbb325..a2f7981d30 100644
--- a/rpc/src/tests/module/miner.rs
+++ b/rpc/src/tests/module/miner.rs
@@ -31,7 +31,7 @@ fn test_get_block_template_cache() {
                 parent
                     .header()
                     .as_advanced_builder()
-                    .timestamp((parent.header().timestamp() + 1).pack())
+                    .timestamp((parent.header().timestamp() + 1).into())
                     .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).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(always_success_cell().2.clone())
             .build();
         let cell_dep = CellDep::new_builder()
diff --git a/rpc/src/tests/module/pool.rs b/rpc/src/tests/module/pool.rs
index f96bb1f24b..808ea89486 100644
--- a/rpc/src/tests/module/pool.rs
+++ b/rpc/src/tests/module/pool.rs
@@ -152,7 +152,7 @@ fn test_send_transaction_exceeded_maximum_ancestors_count() {
                     .unwrap()
                     .safe_sub(Capacity::shannons(i * 41 * 1000))
                     .unwrap()
-                    .pack(),
+                    .into(),
             )
             .lock(always_success_cell().2.clone())
             .build();
@@ -192,7 +192,7 @@ fn build_tx(
     let lock = packed::ScriptBuilder::default()
         .code_hash(code_hash.clone())
         .hash_type(hash_type.into())
-        .args(args.pack())
+        .args(args.as_slice().into())
         .build();
     core::TransactionBuilder::default()
         .output(packed::CellOutput::new_builder().lock(lock).build())
@@ -219,7 +219,7 @@ fn build_tx_with_type(
         .output(
             packed::CellOutput::new_builder()
                 .lock(lock)
-                .type_(Some(type_).pack())
+                .type_(Some(type_).into())
                 .build(),
         )
         .build()
diff --git a/rpc/src/tests/setup.rs b/rpc/src/tests/setup.rs
index 888186fe57..35d4a9b92b 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::{AlertBuilder, RawAlertBuilder},
+    packed::{self, 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.pack())
-        .compact_target(GENESIS_TARGET.pack())
-        .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).pack())
+        .timestamp(GENESIS_TIMESTAMP.into())
+        .compact_target(GENESIS_TARGET.into())
+        .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).into())
         .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: "message".pack().into(),
+            message: Into::<packed::Bytes>::into("message").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.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())
+                    .id(42u32.into())
+                    .min_version(Some("0.0.1".to_string()).into())
+                    .max_version(Some("1.0.0".to_string()).into())
+                    .priority(1u32.into())
+                    .notice_until((ALERT_UNTIL_TIMESTAMP * 1000).into())
+                    .message("An example alert message!".into())
                     .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).pack())
+                    .timestamp((parent.header().timestamp() + 1).into())
                     .build(),
             )
             .build();
diff --git a/script/fuzz/fuzz_targets/syscall_exec.rs b/script/fuzz/fuzz_targets/syscall_exec.rs
index 7e03cabcb5..63e6d69ccd 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.pack())
-        .block_epoch(0u64.pack())
+        .block_number(1u64.into())
+        .block_epoch(0u64.into())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.pack())
+                .index(1u32.into())
                 .build(),
         )
         .build()
-        .unpack()
+        .into()
 }
 
 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().pack())
+        .capacity(Capacity::bytes(exec_caller_cell_data.len()).unwrap().into())
         .build();
     let exec_callee_cell = CellOutput::new_builder()
-        .capacity(Capacity::bytes(exec_callee_cell_data.len()).unwrap().pack())
+        .capacity(Capacity::bytes(exec_callee_cell_data.len()).unwrap().into())
         .build();
     let exec_caller_data_cell = CellOutput::new_builder()
-        .capacity(Capacity::bytes(exec_caller_data_data.len()).unwrap().pack())
+        .capacity(Capacity::bytes(exec_caller_data_data.len()).unwrap().into())
         .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).pack())
+        .capacity(capacity_bytes!(100).into())
         .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.pack()])
+        .set_witnesses(vec![exec_callee_cell_data.into()])
         .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.pack()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).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 ccb922337e..3c2591d51c 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.pack())
-        .block_epoch(0u64.pack())
+        .block_number(1u64.into())
+        .block_epoch(0u64.into())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.pack())
+                .index(1u32.into())
                 .build(),
         )
         .build()
-        .unpack()
+        .into()
 }
 
 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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
+    .out_point(OutPoint::new(h256!("0x0").into(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .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.pack()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).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 f9be40d6be..b005620b01 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.pack())
-        .block_epoch(0u64.pack())
+        .block_number(1u64.into())
+        .block_epoch(0u64.into())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.pack())
+                .index(1u32.into())
                 .build(),
         )
         .build()
-        .unpack()
+        .into()
 }
 
 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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
+    .out_point(OutPoint::new(h256!("0x0").into(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .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.pack()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).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 8c05a5baab..c14fb5d109 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.pack())
-        .block_epoch(0u64.pack())
+        .block_number(1u64.into())
+        .block_epoch(0u64.into())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.pack())
+                .index(1u32.into())
                 .build(),
         )
         .build()
-        .unpack()
+        .into()
 }
 
 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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
+    .out_point(OutPoint::new(h256!("0x0").into(), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .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.pack()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.into()).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 0dee77937f..e7f4253e1e 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().unpack();
+                let capacity: Capacity = output.capacity().into();
                 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 8f19c0d6c9..33f427e822 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().unpack())?;
+                buffer.write_u64::<LittleEndian>(input.since().into())?;
                 store_data(machine, &buffer)
             }
         }
diff --git a/script/src/syscalls/tests/utils.rs b/script/src/syscalls/tests/utils.rs
index de9ca6f542..b8e43abf03 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.pack());
+    let builder = CellOutput::new_builder().capacity(capacity.into());
     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 761537e2ff..00ca304753 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::{CellInput, CellOutput, OutPoint, Script, ScriptBuilder},
+    packed::{self, 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.pack()).build(),
+        cell_output: CellOutput::new_builder().capacity(capacity.into()).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.pack()).build(),
+        cell_output: CellOutput::new_builder().capacity(100.into()).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.pack()).build(),
+        cell_output: CellOutput::new_builder().capacity(100.into()).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).pack();
+    let data_hash = blake2b_256(data).into();
     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.pack()).build(),
+        cell_output: CellOutput::new_builder().capacity(100.into()).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.pack())
-        .number(2000.pack())
-        .epoch(epoch.pack())
+        .transactions_root(data_hash.into())
+        .number(2000.into())
+        .epoch(epoch.into())
         .build();
 
     let mut correct_data = [0u8; 8];
@@ -848,7 +848,7 @@ fn _test_load_tx_hash(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_TX_HASH_SYSCALL_NUMBER); // syscall number
 
     let transaction_view = TransactionBuilder::default()
-        .output_data(data.pack())
+        .output_data(data.into())
         .build();
 
     let hash = transaction_view.hash();
@@ -899,7 +899,7 @@ fn _test_load_tx(data: &[u8]) -> Result<(), TestCaseError> {
     machine.set_register(A7, LOAD_TRANSACTION_SYSCALL_NUMBER); // syscall number
 
     let transaction_view = TransactionBuilder::default()
-        .output_data(data.pack())
+        .output_data(data.into())
         .build();
 
     let tx = transaction_view.data();
@@ -950,7 +950,7 @@ 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()).pack())
+        .args(Bytes::from(data.to_owned()).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let hash = script.calc_script_hash();
@@ -1005,7 +1005,7 @@ 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()).pack())
+        .args(Bytes::from(data.to_owned()).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let h = script.calc_script_hash();
@@ -1071,7 +1071,7 @@ 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()).pack())
+        .args(Bytes::from(data.to_owned()).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let lock = script.as_slice();
@@ -1139,7 +1139,7 @@ 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()).pack())
+        .args(Bytes::from(data.to_owned()).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let type_ = script.as_slice();
@@ -1149,7 +1149,7 @@ fn _test_load_input_type_script(data: &[u8]) -> Result<(), TestCaseError> {
         .cell_output
         .clone()
         .as_builder()
-        .type_(Some(script.to_owned()).pack())
+        .type_(Some(script.to_owned()).into())
         .build();
     input_cell.cell_output = output_with_type;
 
@@ -1207,7 +1207,7 @@ 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()).pack())
+        .args(Bytes::from(data.to_owned()).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
 
@@ -1219,7 +1219,7 @@ fn _test_load_input_type_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
         .cell_output
         .clone()
         .as_builder()
-        .type_(Some(script).pack())
+        .type_(Some(script).into())
         .build();
     input_cell.cell_output = output_with_type;
     let outputs = Arc::new(vec![]);
@@ -1274,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 = Bytes::from(data.to_owned()).pack();
+    let witness: packed::Bytes = Bytes::from(data.to_owned()).into();
 
     let witness_correct_data = witness.raw_data();
 
@@ -1283,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(witnesses.pack())
+            .witnesses(Into::<packed::BytesVec>::into(witnesses))
             .build(),
         resolved_cell_deps: vec![],
         resolved_inputs: vec![],
@@ -1338,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 = Bytes::from(data.to_owned()).pack();
+    let witness: packed::Bytes = Bytes::from(data.to_owned()).into();
 
     let witness_correct_data = witness.raw_data();
 
-    let dummy_witness = Bytes::default().pack();
+    let dummy_witness = Bytes::default().into();
     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(witnesses.pack())
+            .witnesses(Into::<packed::BytesVec>::into(witnesses))
             .build(),
         resolved_cell_deps: vec![],
         resolved_inputs: vec![],
@@ -1397,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()).pack())
+        .args(Bytes::from(data.to_owned()).into())
         .build();
     let script_correct_data = script.as_slice();
 
@@ -1962,15 +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).pack();
+    let hash = blake2b_256(&data).into();
     let input = CellInput::new_builder()
         .previous_output(
             OutPoint::new_builder()
                 .tx_hash(hash)
-                .index(0u32.pack())
+                .index(0u32.into())
                 .build(),
         )
-        .since(10u64.pack())
+        .since(10u64.into())
         .build();
     let previous_output = input.previous_output();
 
@@ -1988,7 +1988,7 @@ fn _test_load_input(
         match field {
             InputField::OutPoint => previous_output.as_slice(),
             InputField::Since => {
-                buffer.write_u64::<LittleEndian>(input.since().unpack())?;
+                buffer.write_u64::<LittleEndian>(input.since().into())?;
                 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 4cac872f56..8d4ae72ca3 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.pack()).build(),
+        cell_output: CellOutput::new_builder().capacity(100.into()).build(),
         data_bytes: 0,
         mem_cell_data: None,
         mem_cell_data_hash: None,
     };
 
     let mut extensions = HashMap::default();
-    extensions.insert(header.hash(), data.pack());
+    extensions.insert(header.hash(), (&data).into());
     let data_loader = MockDataLoader {
         extensions,
         ..Default::default()
diff --git a/script/src/verify.rs b/script/src/verify.rs
index f91328e598..d7a1b88e7f 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.pack())
+                        .index(index.into())
                         .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.pack()
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.into()
             && 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.pack()
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.into()
             && 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 a69c887575..f65628231a 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).pack())
+        .capacity(capacity_bytes!(100).into())
         .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").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
         .transaction_info(default_transaction_info())
@@ -82,8 +82,8 @@ fn check_signature() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).pack())
-        .code_hash(code_hash.pack())
+        .args(Bytes::from(args).into())
+        .code_hash(code_hash.into())
         .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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -137,21 +137,21 @@ 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").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .type_(
             Some(
                 Script::new_builder()
-                    .code_hash(h256!("0x123456abcd90").pack())
+                    .code_hash(h256!("0x123456abcd90").into())
                     .hash_type(ScriptHashType::Data.into())
                     .build(),
             )
-            .pack(),
+            .into(),
         )
         .build();
     let type_hash = output.type_().to_opt().as_ref().unwrap().calc_script_hash();
@@ -161,7 +161,7 @@ fn check_signature_referenced_via_type_hash() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).pack())
+        .args(Bytes::from(args).into())
         .code_hash(type_hash)
         .hash_type(ScriptHashType::Type.into())
         .build();
@@ -173,7 +173,7 @@ fn check_signature_referenced_via_type_hash() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -213,19 +213,19 @@ fn check_invalid_signature() {
     args.extend(&to_hex_signature(&signature));
 
     let code_hash = blake2b_256(&buffer);
-    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .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).pack())
-        .code_hash(code_hash.pack())
+        .args(Bytes::from(args).into())
+        .code_hash(code_hash.into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -236,7 +236,7 @@ fn check_invalid_signature() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -270,12 +270,12 @@ 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").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
     let cell_dep = CellDep::new_builder().out_point(dep_out_point).build();
 
-    let script_code_hash = blake2b_256(&buffer).pack();
+    let script_code_hash: Byte32 = blake2b_256(&buffer).into();
     let script = Script::new_builder()
-        .args(Bytes::from(args).pack())
+        .args(Bytes::from(args).into())
         .code_hash(script_code_hash.clone())
         .hash_type(ScriptHashType::Data.into())
         .build();
@@ -287,7 +287,7 @@ fn check_invalid_dep_reference() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -325,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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -337,8 +337,8 @@ fn check_output_contract() {
     .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).pack())
-        .code_hash(blake2b_256(&buffer).pack())
+        .args(Bytes::from(args).into())
+        .code_hash(blake2b_256(&buffer).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let output_data = Bytes::default();
@@ -348,17 +348,17 @@ fn check_output_contract() {
                 .hash_type(ScriptHashType::Data.into())
                 .build(),
         )
-        .type_(Some(script).pack())
+        .type_(Some(script).into())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build();
         CellMetaBuilder::from_cell_output(output, data)
             .transaction_info(default_transaction_info())
@@ -369,7 +369,7 @@ fn check_output_contract() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(output_data.pack())
+        .output_data(output_data.into())
         .cell_dep(cell_dep)
         .build();
 
@@ -406,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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -418,20 +418,20 @@ fn check_invalid_output_contract() {
     .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).pack())
-        .code_hash(blake2b_256(&buffer).pack())
+        .args(Bytes::from(args).into())
+        .code_hash(blake2b_256(&buffer).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let output = CellOutputBuilder::default()
-        .type_(Some(script.clone()).pack())
+        .type_(Some(script.clone()).into())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+            .capacity(Capacity::bytes(dep_cell_data.len()).unwrap().into())
             .build();
         CellMetaBuilder::from_cell_output(output, dep_cell_data)
             .transaction_info(default_transaction_info())
@@ -441,7 +441,7 @@ fn check_invalid_output_contract() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .cell_dep(cell_dep)
         .build();
 
@@ -477,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).pack())
-        .code_hash(blake2b_256(&buffer).pack())
+        .args(Bytes::from(args).into())
+        .code_hash(blake2b_256(&buffer).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
         .transaction_info(default_transaction_info())
@@ -502,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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(script.clone())
-        .type_(Some(script).pack())
+        .type_(Some(script).into())
         .build();
     let dummy_cell = create_dummy_cell(output);
 
@@ -527,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(Bytes::from(h256!("0x1111").as_ref()).into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).pack())
+        .type_(Some(type_id_script).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -592,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(Bytes::from(h256!("0x1111").as_ref()).into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).pack())
+        .type_(Some(type_id_script).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -657,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
         .build();
 
@@ -675,15 +675,15 @@ fn check_type_id_creation() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash.pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(input_hash.into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).pack())
+        .type_(Some(type_id_script).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -724,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(Bytes::from(h256!("0x1111").as_ref()).into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).pack())
+        .type_(Some(type_id_script).into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
         .build();
 
@@ -782,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
         .build();
 
@@ -794,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().unpack());
+        LittleEndian::write_u32(&mut buf, input.previous_output().index().into());
         blake2b.update(&buf[..]);
         let mut buf = [0; 8];
         LittleEndian::write_u64(&mut buf, 0);
@@ -806,15 +806,15 @@ fn check_type_id_invalid_creation() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash.pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(input_hash.into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -858,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
         .build();
 
@@ -870,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().unpack());
+        LittleEndian::write_u32(&mut buf, input.previous_output().index().into());
         blake2b.update(&buf[..]);
         let mut buf = [0; 8];
         LittleEndian::write_u64(&mut buf, 0);
@@ -885,15 +885,15 @@ fn check_type_id_invalid_creation_length() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash.pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(input_hash.into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -937,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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(Bytes::from(h256!("0x1111").as_ref()).into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(2000).pack())
+        .capacity(capacity_bytes!(2000).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
     let output_cell2 = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -1032,7 +1032,7 @@ 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.pack()
+        vec.into()
     };
 
     let (dyn_lock_cell, dyn_lock_data_hash) =
@@ -1044,7 +1044,7 @@ fn create_rtx_to_load_code_to_stack_then_reuse(
         .args(args)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(dyn_lock_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1111,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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -1123,7 +1123,7 @@ fn check_debugger() {
     .build();
 
     let script = Script::new_builder()
-        .code_hash(blake2b_256(&buffer).pack())
+        .code_hash(blake2b_256(&buffer).into())
         .hash_type(ScriptHashType::Data.into())
         .build();
     let output_data = Bytes::default();
@@ -1133,17 +1133,17 @@ fn check_debugger() {
                 .hash_type(ScriptHashType::Data.into())
                 .build(),
         )
-        .type_(Some(script).pack())
+        .type_(Some(script).into())
         .build();
 
-    let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap().into())
             .build();
         CellMetaBuilder::from_cell_output(output, data)
             .transaction_info(default_transaction_info())
@@ -1154,7 +1154,7 @@ fn check_debugger() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(output_data.pack())
+        .output_data(output_data.into())
         .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 cb70fb0b4c..30c8d0f71d 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2021.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
@@ -32,7 +32,7 @@ fn test_hint_instructions() {
         .code_hash(always_success_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(always_success_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -73,7 +73,7 @@ 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.pack()
+        vec.into()
     };
 
     let (cpop_lock_cell, cpop_lock_data_hash) = load_cell_from_path("testdata/cpop_lock");
@@ -84,7 +84,7 @@ fn test_b_extension() {
         .args(args)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(cpop_lock_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -132,7 +132,7 @@ fn test_cycles_difference() {
         .code_hash(always_success_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(always_success_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -171,7 +171,7 @@ fn check_current_cycles() {
         .code_hash(current_cycles_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(current_cycles_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -203,7 +203,7 @@ fn check_current_cycles_with_snapshot() {
         .code_hash(current_cycles_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(current_cycles_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -248,7 +248,7 @@ fn check_vm_version() {
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -280,7 +280,7 @@ fn check_vm_version_with_snapshot() {
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -327,7 +327,7 @@ fn check_exec_from_cell_data() {
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -360,7 +360,7 @@ fn check_exec_from_witness() {
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .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.pack()])
+        .set_witnesses(vec![exec_callee_cell_data.into()])
         .build();
     let dummy_cell = create_dummy_cell(output);
 
@@ -403,7 +403,7 @@ fn check_exec_wrong_callee_format() {
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -473,7 +473,7 @@ fn check_exec_big_offset_length() {
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(Bytes::from(h256!("0x1111").as_ref()).into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).pack())
+        .type_(Some(type_id_script).into())
         .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").pack(), 0);
+    let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).pack())
-        .code_hash(TYPE_ID_CODE_HASH.pack())
+        .args(Bytes::from(h256!("0x1111").as_ref()).into())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
-    let input = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 8), 0);
+    let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).pack())
+        .capacity(capacity_bytes!(1000).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).pack())
+        .type_(Some(type_id_script.clone()).into())
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).pack())
+        .capacity(capacity_bytes!(990).into())
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).pack())
+        .type_(Some(type_id_script).into())
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -1045,7 +1045,7 @@ 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.pack()
+            vec.into()
         };
 
         let (dyn_lock_cell, dyn_lock_data_hash) =
@@ -1057,7 +1057,7 @@ fn load_code_into_global() {
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(dyn_lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1101,7 +1101,7 @@ 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.pack()
+            vec.into()
         };
 
         let (dyn_lock_cell, dyn_lock_data_hash) =
@@ -1113,7 +1113,7 @@ fn load_code_with_snapshot() {
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(dyn_lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1202,7 +1202,7 @@ 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.pack()
+            vec.into()
         };
 
         let lock_script = Script::new_builder()
@@ -1211,7 +1211,7 @@ fn load_code_with_snapshot_more_times() {
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .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.pack()
+        vec.into()
     };
 
     let rtx = {
@@ -1348,7 +1348,7 @@ fn test_exec(
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .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.pack()])
+                    .set_witnesses(vec![exec_callee_cell_data.into()])
                     .build();
                 (tx, vec![create_dummy_cell(output)])
             }
@@ -1372,7 +1372,7 @@ fn test_exec(
 
                 let tx = TransactionBuilder::default()
                     .input(input)
-                    .set_witnesses(vec![data.pack()])
+                    .set_witnesses(vec![data.into()])
                     .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).pack())
-                    .type_(Some(exec_caller_script).pack())
+                    .capacity(capacity_bytes!(100).into())
+                    .type_(Some(exec_caller_script).into())
                     .build();
                 let tx = TransactionBuilder::default()
                     .output(output)
-                    .set_witnesses(vec![exec_callee_cell_data.pack()])
+                    .set_witnesses(vec![exec_callee_cell_data.into()])
                     .build();
                 (tx, vec![])
             }
             ExecFrom::TxInputCell => {
                 let callee_output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .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).pack())
+                    .capacity(capacity_bytes!(100).into())
                     .lock(exec_caller_script)
-                    .type_(Some(always_success_script.clone()).pack())
+                    .type_(Some(always_success_script.clone()).into())
                     .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).pack())
+                    .capacity(capacity_bytes!(100).into())
                     .lock(always_success_script.clone())
                     .build();
                 let tx = TransactionBuilder::default()
                     .input(input)
                     .output(callee_output)
-                    .output_data(exec_callee_cell_data.pack())
+                    .output_data(exec_callee_cell_data.into())
                     .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).pack())
-                    .type_(Some(exec_caller_script).pack())
+                    .capacity(capacity_bytes!(100).into())
+                    .type_(Some(exec_caller_script).into())
                     .build();
                 let tx = TransactionBuilder::default()
                     .output(callee_output)
-                    .output_data(exec_callee_cell_data.pack())
+                    .output_data(exec_callee_cell_data.into())
                     .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.pack()])
+                    .set_witnesses(vec![exec_callee_cell_data.into()])
                     .build();
                 (tx, vec![create_dummy_cell(output)])
             }
         };
 
-        let always_success_out_point = OutPoint::new(h256!("0x11").pack(), 0);
+        let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
         let resolved_always_success_cell = CellMetaBuilder::from_cell_output(
             always_success_cell.clone(),
             always_success_cell_data.to_owned(),
@@ -1793,20 +1793,20 @@ 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").pack(), 8);
+    let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
     let cell_dep = CellDep::new_builder()
         .out_point(dep_out_point.clone())
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .type_(
             Some(
                 Script::new_builder()
-                    .code_hash(h256!("0x123456abcd90").pack())
+                    .code_hash(h256!("0x123456abcd90").into())
                     .hash_type(ScriptHashType::Data.into())
                     .build(),
             )
-            .pack(),
+            .into(),
         )
         .build();
     let type_hash = output.type_().to_opt().as_ref().unwrap().calc_script_hash();
@@ -1815,20 +1815,20 @@ 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").pack(), 8);
+    let dep_out_point2 = OutPoint::new(h256!("0x1234").into(), 8);
     let cell_dep2 = CellDep::new_builder()
         .out_point(dep_out_point2.clone())
         .build();
     let output2 = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .type_(
             Some(
                 Script::new_builder()
-                    .code_hash(h256!("0x123456abcd90").pack())
+                    .code_hash(h256!("0x123456abcd90").into())
                     .hash_type(ScriptHashType::Data.into())
                     .build(),
             )
-            .pack(),
+            .into(),
         )
         .build();
     let dep_cell2 = CellMetaBuilder::from_cell_output(output2, data)
@@ -1837,7 +1837,7 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).pack())
+        .args(Bytes::from(args).into())
         .code_hash(type_hash)
         .hash_type(ScriptHashType::Type.into())
         .build();
@@ -1850,7 +1850,7 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
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 4cb4fd8583..5006ca1996 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2023.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
@@ -120,7 +120,7 @@ fn check_vm_version() {
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -140,6 +140,71 @@ fn check_vm_version() {
     assert_eq!(result.is_ok(), script_version == ScriptVersion::V2);
 }
 
+#[test]
+fn check_get_memory_limit() {
+    let script_version = SCRIPT_VERSION;
+
+    let (memory_limit_cell, memory_limit_data_hash) =
+        load_cell_from_path("testdata/get_memory_limit");
+
+    let memory_limit_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(memory_limit_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(memory_limit_script)
+        .build();
+
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![memory_limit_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_set_content() {
+    let script_version = SCRIPT_VERSION;
+
+    let (set_content_cell, set_content_data_hash) = load_cell_from_path("testdata/set_content");
+
+    let memory_limit_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(set_content_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(memory_limit_script)
+        .build();
+
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![set_content_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
 #[test]
 fn check_spawn_strcat() {
     let script_version = SCRIPT_VERSION;
@@ -154,7 +219,106 @@ fn check_spawn_strcat() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_strcat_data_hash() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_caller_strcat_data_hash");
+    let (spawn_callee_cell, _spawn_callee_data_hash) =
+        load_cell_from_path("testdata/spawn_callee_strcat");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_get_memory_limit() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_caller_get_memory_limit");
+    let (spawn_callee_cell, _spawn_callee_data_hash) =
+        load_cell_from_path("testdata/spawn_callee_get_memory_limit");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_set_content() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_caller_set_content");
+    let (spawn_callee_cell, _spawn_callee_data_hash) =
+        load_cell_from_path("testdata/spawn_callee_set_content");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -187,7 +351,7 @@ fn check_spawn_out_of_cycles() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -227,7 +391,7 @@ fn check_spawn_exec() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -264,7 +428,7 @@ fn check_spawn_strcat_wrap() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -301,7 +465,7 @@ fn check_spawn_out_of_cycles_wrap() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -343,7 +507,7 @@ fn check_spawn_recursive() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -367,6 +531,161 @@ fn check_spawn_recursive() {
     }
 }
 
+#[test]
+fn check_spawn_big_memory_size() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_big_memory_size");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_big_content_length() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_big_content_length");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_peak_memory_4m_to_32m() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_peak_memory_4m_to_32m");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_peak_memory_2m_to_32m() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_peak_memory_2m_to_32m");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
+#[test]
+fn check_peak_memory_512k_to_32m() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_peak_memory_512k_to_32m");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
 #[test]
 fn check_spawn_snapshot() {
     let script_version = SCRIPT_VERSION;
@@ -383,7 +702,7 @@ fn check_spawn_snapshot() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -560,7 +879,7 @@ fn check_spawn_state() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -614,6 +933,37 @@ fn check_spawn_state() {
     assert!(chunks_count > 1);
 }
 
+#[test]
+fn check_spawn_current_memory() {
+    let script_version = SCRIPT_VERSION;
+
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_current_memory");
+
+    let spawn_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(spawn_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).into())
+        .lock(spawn_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
+
 #[test]
 fn check_spawn_current_cycles() {
     let script_version = SCRIPT_VERSION;
@@ -628,7 +978,7 @@ fn check_spawn_current_cycles() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -705,6 +1055,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
         .code_hash(spawn_caller_data_hash)
         .args(args.pack())
         .build();
+
     let always_success_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
         .code_hash(always_success_data_hash)
@@ -1194,7 +1545,7 @@ fn check_spawn_huge_swap() {
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(spawn_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 760921f627..43b404d195 100644
--- a/script/src/verify/tests/utils.rs
+++ b/script/src/verify/tests/utils.rs
@@ -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().pack())
+        .capacity(Capacity::bytes(cell_data.len()).unwrap().into())
         .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.pack())
-        .block_epoch(0u64.pack())
+        .block_number(1u64.into())
+        .block_epoch(0u64.into())
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.pack())
+                .index(1u32.into())
                 .build(),
         )
         .build()
-        .unpack()
+        .into()
 }
 
 pub(crate) struct TransactionScriptsVerifierWithEnv {
@@ -310,7 +310,7 @@ impl TransactionScriptsVerifierWithEnv {
             ScriptVersion::V2 => EpochNumberWithFraction::new(self.version_2_enabled_at, 0, 1),
         };
         let header = HeaderView::new_advanced_builder()
-            .epoch(epoch.pack())
+            .epoch(epoch.into())
             .build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let mut verifier = TransactionScriptsVerifier::new(
@@ -339,8 +339,8 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .dep_type(DepType::DepGroup.into())
         .build();
 
-    let input1 = CellInput::new(OutPoint::new(h256!("0x1234").pack(), 0), 0);
-    let input2 = CellInput::new(OutPoint::new(h256!("0x1111").pack(), 0), 0);
+    let input1 = CellInput::new(OutPoint::new(h256!("0x1234").into(), 0), 0);
+    let input2 = CellInput::new(OutPoint::new(h256!("0x1111").into(), 0), 0);
 
     let mut generator = Generator::non_crypto_safe_prng(42);
     let privkey = generator.gen_privkey();
@@ -351,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.pack())
-        .code_hash(type_lock_script_code_hash().pack())
+        .args(lock_arg.into())
+        .code_hash(type_lock_script_code_hash().into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
     let lock2 = Script::new_builder()
-        .args(lock_arg2.pack())
-        .code_hash(type_lock_script_code_hash().pack())
+        .args(lock_arg2.into())
+        .code_hash(type_lock_script_code_hash().into())
         .hash_type(ScriptHashType::Type.into())
         .build();
 
     let output1 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(lock.clone())
         .build();
     let output2 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(lock2.clone())
         .build();
     let tx = TransactionBuilder::default()
@@ -380,11 +380,11 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .output_data(Default::default())
         .build();
 
-    let tx_hash: H256 = tx.hash().unpack();
+    let tx_hash: H256 = tx.hash().into();
     // sign input1
     let witness = {
         WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+            .lock(Some(Bytes::from(vec![0u8; 65])).into())
             .build()
     };
     let witness_len: u64 = witness.as_bytes().len() as u64;
@@ -399,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())).pack())
+        .lock(Some(Bytes::from(sig.serialize())).into())
         .build();
     // sign input2
     let witness2 = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+        .lock(Some(Bytes::from(vec![0u8; 65])).into())
         .build();
     let witness2_len: u64 = witness2.as_bytes().len() as u64;
     let mut hasher = new_blake2b();
@@ -417,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())).pack())
+        .lock(Some(Bytes::from(sig2.serialize())).into())
         .build();
     let tx = tx
         .as_advanced_builder()
-        .witness(witness.as_bytes().pack())
-        .witness(witness2.as_bytes().pack())
+        .witness(witness.as_bytes().into())
+        .witness(witness2.as_bytes().into())
         .build();
 
     let serialized_size = tx.data().as_slice().len() as u64;
@@ -438,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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(lock)
         .build();
 
@@ -447,7 +447,7 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .build();
 
     let input_cell2 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(lock2)
         .build();
 
diff --git a/shared/src/shared.rs b/shared/src/shared.rs
index 2939230a5f..7f30c5d82b 100644
--- a/shared/src/shared.rs
+++ b/shared/src/shared.rs
@@ -220,7 +220,7 @@ impl Shared {
                     e
                 })?;
 
-                let pack_number: packed::Uint64 = number.pack();
+                let pack_number: packed::Uint64 = number.into();
                 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()).unpack();
+                            packed::Uint32Reader::from_slice_should_be_ok(value.as_ref()).into();
                         side.insert(block_hash, (reader.number().to_entity(), txs));
                     }
                 }
@@ -254,12 +254,10 @@ impl Shared {
         if !side.is_empty() {
             // Wipe out side chain
             for (hash, (number, txs)) in &side {
-                batch
-                    .delete_block(number.unpack(), hash, *txs)
-                    .map_err(|e| {
-                        ckb_logger::error!("Freezer delete_block_body failed {}", e);
-                        e
-                    })?;
+                batch.delete_block(number.into(), hash, *txs).map_err(|e| {
+                    ckb_logger::error!("Freezer delete_block_body failed {}", e);
+                    e
+                })?;
             }
 
             self.store.write(&batch).map_err(|e| {
@@ -279,12 +277,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.pack())
+            .index(0u32.into())
             .build();
 
         let end_t = packed::TransactionKey::new_builder()
             .block_hash(end.clone())
-            .index(TX_INDEX_UPPER_BOUND.pack())
+            .index(TX_INDEX_UPPER_BOUND.into())
             .build();
 
         if let Err(e) = self.store.compact_range(
diff --git a/spec/src/consensus.rs b/spec/src/consensus.rs
index 2d8a16c481..1c5463b480 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.pack()).build()
+            empty_output.as_builder().capacity(occupied.into()).build()
         };
         let witness = Script::default().into_witness();
         let cellbase = TransactionBuilder::default()
             .input(input)
             .output(output)
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .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.pack())
-            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).pack())
+            .compact_target(DIFF_TWO.into())
+            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).into())
             .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}", Unpack::<H256>::unpack(&self.genesis_hash));
+        let genesis_hash = format!("{:x}", Into::<H256>::into(&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.unpack(),
-            dao_type_hash: consensus.dao_type_hash.unpack(),
+            genesis_hash: consensus.genesis_hash.into(),
+            dao_type_hash: consensus.dao_type_hash.into(),
             secp256k1_blake160_sighash_all_type_hash: consensus
                 .secp256k1_blake160_sighash_all_type_hash
-                .map(|h| h.unpack()),
+                .map(|h| h.into()),
             secp256k1_blake160_multisig_all_type_hash: consensus
                 .secp256k1_blake160_multisig_all_type_hash
-                .map(|h| h.unpack()),
+                .map(|h| h.into()),
             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 4e029bc6cb..2d54b047c3 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().unpack();
+            let actual: H256 = genesis.hash().into();
             if &actual != expect {
                 return Err(SpecLoadError::genesis_mismatch(expect.clone(), actual));
             }
@@ -609,7 +609,7 @@ impl ChainSpec {
                 .raw()
                 .outputs()
                 .iter()
-                .map(|output| Unpack::<Capacity>::unpack(&output.capacity()))
+                .map(|output| Into::<Capacity>::into(output.capacity()))
                 .try_fold(Capacity::zero(), Capacity::safe_add)
         }?;
 
@@ -633,14 +633,14 @@ impl ChainSpec {
         );
 
         let block = BlockBuilder::default()
-            .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())
+            .version(self.genesis.version.into())
+            .parent_hash((&self.genesis.parent_hash).into())
+            .timestamp(self.genesis.timestamp.into())
+            .compact_target(self.genesis.compact_target.into())
+            .extra_hash((&self.genesis.uncles_hash).into())
+            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).into())
             .dao(dao)
-            .nonce(u128::from_le_bytes(self.genesis.nonce.to_le_bytes()).pack())
+            .nonce(u128::from_le_bytes(self.genesis.nonce.to_le_bytes()).into())
             .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.pack()) != Some(&(tx_index, output_index)) {
+            if data_hashes.get(&hash.into()) != 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())).pack())
-            .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone().pack())
+            .args(secp_lock_arg(&Privkey::from(SPECIAL_CELL_PRIVKEY.clone())).into())
+            .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone().into())
             .hash_type(ScriptHashType::Data.into())
             .build();
         let special_issued_cell = packed::CellOutput::new_builder()
-            .capacity(special_cell_capacity.pack())
+            .capacity(special_cell_capacity.into())
             .lock(special_issued_lock)
             .build();
         outputs.push(special_issued_cell);
@@ -829,7 +829,7 @@ impl ChainSpec {
             .outputs_data(
                 outputs_data
                     .iter()
-                    .map(|d| d.pack())
+                    .map(|d| d.into())
                     .collect::<Vec<packed::Bytes>>(),
             )
             .build();
@@ -872,11 +872,11 @@ impl ChainSpec {
                     })
                     .collect::<Result<_, Box<dyn Error>>>()?;
 
-                let data = out_points.pack().as_bytes();
+                let data = Into::<packed::OutPointVec>::into(out_points).as_bytes();
                 let cell = packed::CellOutput::new_builder()
                     .lock(self.genesis.system_cells_lock.clone().into())
                     .build_exact_capacity(Capacity::bytes(data.len())?)?;
-                Ok((cell, data.pack()))
+                Ok((cell, data.into()))
             })
             .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| Unpack::<Bytes>::unpack(&output.lock().args()) == lock_arg)
+            .position(|output| Into::<Bytes>::into(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.pack())
+            find_out_point_by_data_hash(cellbase_tx, &CODE_HASH_SECP256K1_DATA.into())
                 .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.pack(),
+            &CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.into(),
         )
         .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().unpack();
+        let tx_hash: H256 = tx.hash().into();
         let message = H256::from(blake2b_256(tx_hash));
         let sig = privkey.sign_recoverable(&message).expect("sign");
-        let witness = Bytes::from(sig.serialize()).pack();
+        let witness = Bytes::from(sig.serialize()).into();
 
         Ok(TransactionBuilder::default()
             .cell_deps(cell_deps)
@@ -944,7 +944,7 @@ impl IssuedCell {
     fn build_output(&self) -> packed::CellOutput {
         packed::CellOutput::new_builder()
             .lock(self.lock.clone().into())
-            .capacity(self.capacity.pack())
+            .capacity(self.capacity.into())
             .build()
     }
 }
@@ -963,12 +963,12 @@ impl SystemCell {
             None
         };
         let builder = packed::CellOutput::new_builder()
-            .type_(type_script.pack())
+            .type_(type_script.into())
             .lock(lock.clone().into());
 
         let data_len = Capacity::bytes(data.len())?;
         let cell = if let Some(capacity) = self.capacity {
-            let cell = builder.capacity(capacity.pack()).build();
+            let cell = builder.capacity(capacity.into()).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.pack())
+        .code_hash(TYPE_ID_CODE_HASH.into())
         .hash_type(ScriptHashType::Type.into())
-        .args(script_arg.pack())
+        .args(script_arg.into())
         .build()
 }
 
diff --git a/spec/src/tests/consensus.rs b/spec/src/tests/consensus.rs
index eaa250ad76..d2fe44fe8e 100644
--- a/spec/src/tests/consensus.rs
+++ b/spec/src/tests/consensus.rs
@@ -5,7 +5,6 @@ use ckb_types::{
         HeaderView, TransactionBuilder,
     },
     packed::{Byte32, Bytes},
-    prelude::*,
     utilities::DIFF_TWO,
 };
 
@@ -53,8 +52,8 @@ fn test_halving_epoch_reward() {
 
     let header = |epoch: &EpochExt, number: u64| {
         HeaderBuilder::default()
-            .number(number.pack())
-            .epoch(epoch.number_with_fraction(number).pack())
+            .number(number.into())
+            .epoch(epoch.number_with_fraction(number).into())
             .build()
     };
 
diff --git a/spec/src/tests/mod.rs b/spec/src/tests/mod.rs
index ad621c1597..e5f23bb5b7 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().unpack();
+        let cellbase_hash: H256 = cellbase.hash().into();
 
         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()).unpack();
+            let data_hash: H256 = packed::CellOutput::calc_data_hash(&data.raw_data()).into();
             let type_hash: Option<H256> = output
                 .type_()
                 .to_opt()
-                .map(|script| script.calc_script_hash().unpack());
+                .map(|script| script.calc_script_hash().into());
             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()
-            .unpack();
+            .into();
         let outputs_capacity = dep_group_tx
             .outputs()
             .into_iter()
-            .map(|output| Unpack::<Capacity>::unpack(&output.capacity()))
+            .map(|output| Into::<Capacity>::into(&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 = dep_group.tx_hash.pack();
+            let tx_hash = Into::<packed::Byte32>::into(&dep_group.tx_hash);
             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().unpack();
+                let index_in_cellbase: usize = out_point.index().into();
 
                 // 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 bcbb3aea57..e4aa549b4d 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).pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .number((parent.number() + 1).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
             .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().pack())
+            .message(version.to_le_bytes().as_slice().into())
             .build();
 
-        let witness = cellbase_witness.as_bytes().pack();
+        let witness = cellbase_witness.as_bytes().into();
         let cellbase = TransactionBuilder::default().witness(witness).build();
 
         BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .number((parent.number() + 1).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
             .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).pack())
+        .epoch(epoch_ext.number_with_fraction(0).into())
         .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).pack())
+        .epoch(epoch_ext.number_with_fraction(0).into())
         .transaction(cellbase)
         .build();
 
diff --git a/store/src/cell.rs b/store/src/cell.rs
index 88c6e49e17..d840668230 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.pack())
+                        .index(index.into())
                         .build();
 
                     let entry = packed::CellEntryBuilder::default()
                         .output(cell_output)
                         .block_hash(block_hash.clone())
-                        .block_number(block_number.pack())
-                        .block_epoch(block_epoch.pack())
-                        .index(tx_index.pack())
-                        .data_size((data.len() as u64).pack())
+                        .block_number(block_number.into())
+                        .block_epoch(block_epoch.into())
+                        .index(tx_index.into())
+                        .data_size((data.len() as u64).into())
                         .build();
 
                     let data_entry = if !data.is_empty() {
                         let data_hash = packed::CellOutput::calc_data_hash(&data);
                         Some(
                             packed::CellDataEntryBuilder::default()
-                                .output_data(data.pack())
+                                .output_data(data.into())
                                 .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().unpack();
+            let index: usize = pts.index().into();
             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.pack())
+                                .index(index.into())
                                 .build();
 
                             let entry = packed::CellEntryBuilder::default()
                                 .output(cell_output)
                                 .block_hash(block_hash.clone())
-                                .block_number(block_number.pack())
-                                .block_epoch(block_epoch.pack())
-                                .index(tx_index.pack())
-                                .data_size((data.len() as u64).pack())
+                                .block_number(block_number.into())
+                                .block_epoch(block_epoch.into())
+                                .index(tx_index.into())
+                                .data_size((data.len() as u64).into())
                                 .build();
 
                             let data_entry = if !data.is_empty() {
                                 let data_hash = packed::CellOutput::calc_data_hash(&data);
                                 Some(
                                     packed::CellDataEntryBuilder::default()
-                                        .output_data(data.pack())
+                                        .output_data(data.into())
                                         .output_data_hash(data_hash)
                                         .build(),
                                 )
diff --git a/store/src/store.rs b/store/src/store.rs
index 8e9b69a6d9..90657c5017 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());
-            Unpack::<HeaderView>::unpack(&reader)
+            Into::<HeaderView>::into(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());
-            Unpack::<TransactionView>::unpack(&reader)
+            Into::<TransactionView>::into(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());
-                Unpack::<HeaderView>::unpack(&reader)
+                Into::<HeaderView>::into(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());
-                Unpack::<UncleBlockVecView>::unpack(&reader)
+                Into::<UncleBlockVecView>::into(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());
-            Unpack::<UncleBlockVecView>::unpack(&reader)
+            Into::<UncleBlockVecView>::into(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.unpack(),
-                    2 => packed::BlockExtV1Reader::from_slice_should_be_ok(slice.as_ref()).unpack(),
+                    0 => reader.into(),
+                    2 => packed::BlockExtV1Reader::from_slice_should_be_ok(slice.as_ref()).into(),
                     _ => {
                         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.pack();
+        let block_number: packed::Uint64 = number.into();
         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()).unpack())
+            .map(|raw| packed::Uint64Reader::from_slice_should_be_ok(raw.as_ref()).into())
     }
 
     /// 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());
-                Unpack::<TransactionInfo>::unpack(&reader)
+                Into::<TransactionInfo>::into(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.unpack(), tx_info)
+                (reader.into(), 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().unpack();
+                let data = reader.output_data().into();
                 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()).unpack())
+            .map(|slice| packed::EpochExtReader::from_slice_should_be_ok(slice.as_ref()).into())
     }
 
     /// 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()).unpack())
+            .map(|slice| packed::EpochExtReader::from_slice_should_be_ok(slice.as_ref()).into())
     }
 
     /// Gets epoch index by epoch number
     fn get_epoch_index(&self, number: EpochNumber) -> Option<packed::Byte32> {
-        let epoch_number: packed::Uint64 = number.pack();
+        let epoch_number: packed::Uint64 = number.into();
         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());
-            Unpack::<HeaderView>::unpack(&reader)
+            Into::<HeaderView>::into(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());
-            Unpack::<TransactionView>::unpack(&reader)
+            Into::<TransactionView>::into(reader)
         })
     }
 
@@ -513,7 +513,8 @@ pub trait ChainStore: Send + Sync + Sized {
                 let reader = packed::TransactionViewReader::from_slice_should_be_ok(value.as_ref());
                 reader.data().to_entity()
             })
-            .pack();
+            .collect::<Vec<_>>()
+            .into();
 
         let uncles = self.get_block_uncles(hash)?;
         let proposals = self.get_block_proposal_txs_ids(hash)?;
@@ -550,7 +551,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.pack();
+        let position: packed::Uint64 = position_u64.into();
         self.get(COLUMN_CHAIN_ROOT_MMR, position.as_slice())
             .map(|slice| {
                 let reader = packed::HeaderDigestReader::from_slice_should_be_ok(slice.as_ref());
@@ -579,12 +580,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().unpack(),
+            block_number: reader.block_number().into(),
             block_hash: reader.block_hash().to_entity(),
-            block_epoch: reader.block_epoch().unpack(),
-            index: reader.index().unpack(),
+            block_epoch: reader.block_epoch().into(),
+            index: reader.index().into(),
         }),
-        data_bytes: reader.data_size().unpack(),
+        data_bytes: reader.data_size().into(),
         mem_cell_data: None,
         mem_cell_data_hash: None,
     }
diff --git a/store/src/tests/db.rs b/store/src/tests/db.rs
index 39e1d24d61..39aff4e9a7 100644
--- a/store/src/tests/db.rs
+++ b/store/src/tests/db.rs
@@ -32,7 +32,7 @@ fn save_and_get_block_with_transactions() {
             (0..3)
                 .map(|_| packed::Transaction::new_builder().build())
                 .collect::<Vec<_>>()
-                .pack(),
+                .into(),
         )
         .build()
         .into_view();
@@ -98,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.pack()).build();
+    let raw = packed::RawHeader::new_builder().number(1u64.into()).build();
     let block = packed::Block::new_builder()
         .header(packed::Header::new_builder().raw(raw).build())
         .build()
@@ -111,7 +111,7 @@ fn freeze_blockv0() {
     txn.insert_raw(
         COLUMN_BLOCK_HEADER,
         block_hash.as_slice(),
-        header.pack().as_slice(),
+        Into::<packed::HeaderView>::into(header).as_slice(),
     )
     .expect("insert header");
     txn.commit().expect("commit");
@@ -131,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].pack();
-    let raw = packed::RawHeader::new_builder().number(1u64.pack()).build();
+    let extension: packed::Bytes = [1u8; 96].as_slice().into();
+    let raw = packed::RawHeader::new_builder().number(1u64.into()).build();
     let block = packed::BlockV1::new_builder()
         .header(packed::Header::new_builder().raw(raw).build())
         .extension(extension)
@@ -147,7 +147,7 @@ fn freeze_blockv1_with_extension() {
     txn.insert_raw(
         COLUMN_BLOCK_HEADER,
         block_hash.as_slice(),
-        header.pack().as_slice(),
+        Into::<packed::HeaderView>::into(header).as_slice(),
     )
     .expect("insert header");
     txn.commit().expect("commit");
diff --git a/store/src/transaction.rs b/store/src/transaction.rs
index 62ba110b0f..ea7506728e 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 = block.header().pack();
-        let uncles = block.uncles().pack();
+        let header = Into::<packed::HeaderView>::into(block.header());
+        let uncles = Into::<packed::UncleBlockVecView>::into(block.uncles());
         let proposals = block.data().proposals();
-        let txs_len: packed::Uint32 = (block.transactions().len() as u32).pack();
+        let txs_len: packed::Uint32 = (block.transactions().len() as u32).into();
         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().pack())
+                .number(block.number().into())
                 .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.pack())
+                .index(index.into())
                 .build();
-            let tx_data = tx.pack();
+            let tx_data = Into::<packed::TransactionView>::into(tx);
             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().pack())
+                .number(block.number().into())
                 .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.pack())
+                .index(index.into())
                 .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.pack();
+        let packed_ext: packed::BlockExtV1 = ext.into();
         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.pack())
+                .index(index.into())
                 .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().pack();
+        let block_number: packed::Uint64 = block.number().into();
         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(),
-                uncle.header().pack().as_slice(),
+                Into::<packed::HeaderView>::into(uncle.header()).as_slice(),
             )?;
         }
         self.insert_raw(COLUMN_INDEX, block_hash.as_slice(), block_number.as_slice())
@@ -309,14 +309,22 @@ 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(), epoch.pack().as_slice())?;
-        let epoch_number: packed::Uint64 = epoch.number().pack();
+        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, 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, epoch.pack().as_slice())
+        self.insert_raw(
+            COLUMN_META,
+            META_CURRENT_EPOCH_KEY,
+            Into::<packed::EpochExt>::into(epoch).as_slice(),
+        )
     }
 
     /// TODO(doc): @quake
@@ -368,7 +376,7 @@ impl StoreTransaction {
         position_u64: u64,
         header_digest: &packed::HeaderDigest,
     ) -> Result<(), Error> {
-        let position: packed::Uint64 = position_u64.pack();
+        let position: packed::Uint64 = position_u64.into();
         self.insert_raw(
             COLUMN_CHAIN_ROOT_MMR,
             position.as_slice(),
@@ -378,7 +386,7 @@ impl StoreTransaction {
 
     /// Deletes a header digest.
     pub fn delete_header_digest(&self, position_u64: u64) -> Result<(), Error> {
-        let position: packed::Uint64 = position_u64.pack();
+        let position: packed::Uint64 = position_u64.into();
         self.delete(COLUMN_CHAIN_ROOT_MMR, position.as_slice())
     }
 
diff --git a/store/src/write_batch.rs b/store/src/write_batch.rs
index 65d74e2dc1..367b9bb165 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.pack())
+                .number(number.into())
                 .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.pack())
+                .index(i.into())
                 .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 a194525052..56ef4e08db 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().unpack();
+        let start_number: BlockNumber = self.message.to_entity().start_number().into();
         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.pack())
-                .block_filter_hashes(block_filter_hashes.pack())
+                .start_number(start_number.into())
+                .block_filter_hashes(block_filter_hashes.into())
                 .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 c1a3f5a6e0..25142bc2d6 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().unpack();
+        let start_number: BlockNumber = self.message.to_entity().start_number().into();
         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.pack())
+                .start_number(start_number.into())
                 .parent_block_filter_hash(parent_block_filter_hash)
-                .block_filter_hashes(block_filter_hashes.pack())
+                .block_filter_hashes(block_filter_hashes.into())
                 .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 22e527f0e5..8d8257a04b 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().unpack();
+        let start_number: BlockNumber = self.message.to_entity().start_number().into();
         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.pack())
-                .block_hashes(block_hashes.pack())
-                .filters(filters.pack())
+                .start_number(start_number.into())
+                .block_hashes(block_hashes.into())
+                .filters(filters.into())
                 .build();
 
             let message = packed::BlockFilterMessage::new_builder()
diff --git a/sync/src/net_time_checker.rs b/sync/src/net_time_checker.rs
index 259a2eae57..3b7c2acc79 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.pack()).build();
+            let time = packed::Time::new_builder().timestamp(now.into()).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().unpack())
+            .map(|time| time.timestamp().into())
             .ok()
         {
             Some(timestamp) => timestamp,
diff --git a/sync/src/relayer/block_transactions_process.rs b/sync/src/relayer/block_transactions_process.rs
index fa5522e349..6e380b1751 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.pack())
-                    .uncle_indexes(missing_uncles.pack())
+                    .indexes(missing_transactions.as_slice().into())
+                    .uncle_indexes(missing_uncles.as_slice().into())
                     .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 b46dcca1ef..483570f807 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, _, _)| {
-                    Unpack::<EpochNumberWithFraction>::unpack(&v.header().as_reader().raw().epoch())
+                    Into::<EpochNumberWithFraction>::into(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.pack())
-        .uncle_indexes(missing_uncles.pack())
+        .indexes(missing_transactions.as_slice().into())
+        .uncle_indexes(missing_uncles.as_slice().into())
         .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 549735c1cb..61ce34772e 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, prelude::*};
+use ckb_types::packed;
 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().unpack();
+            let index: usize = prefilled_transactions.get(0).unwrap().index().into();
             if index != 0 {
                 return StatusCode::CompactBlockHasNotPrefilledCellbase.into();
             }
@@ -38,7 +38,7 @@ impl PrefilledVerifier {
                 .get(prefilled_transactions.len() - 1)
                 .unwrap()
                 .index()
-                .unpack();
+                .into();
             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().unpack();
-            let idx1: usize = prefilled_transactions.get(i + 1).unwrap().index().unpack();
+            let idx0: usize = prefilled_transactions.get(i).unwrap().index().into();
+            let idx1: usize = prefilled_transactions.get(i + 1).unwrap().index().into();
             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 b7321ba1c3..052c684c37 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.into_iter().pack())
+            .transactions(txs.into())
             .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 bfff3ebc11..acb332993f 100644
--- a/sync/src/relayer/get_block_transactions_process.rs
+++ b/sync/src/relayer/get_block_transactions_process.rs
@@ -4,6 +4,7 @@ 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;
 
@@ -65,7 +66,7 @@ impl<'a> GetBlockTransactionsProcess<'a> {
                 .filter_map(|i| {
                     block
                         .transactions()
-                        .get(Unpack::<u32>::unpack(&i) as usize)
+                        .get(Into::<u32>::into(i) as usize)
                         .cloned()
                 })
                 .collect::<Vec<_>>();
@@ -74,13 +75,25 @@ impl<'a> GetBlockTransactionsProcess<'a> {
                 .message
                 .uncle_indexes()
                 .iter()
-                .filter_map(|i| block.uncles().get(Unpack::<u32>::unpack(&i) as usize))
+                .filter_map(|i| block.uncles().get(Into::<u32>::into(i) as usize))
                 .collect::<Vec<_>>();
 
             let content = packed::BlockTransactions::new_builder()
                 .block_hash(block_hash)
-                .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
-                .uncles(uncles.into_iter().map(|uncle| uncle.data()).pack())
+                .transactions(
+                    transactions
+                        .into_iter()
+                        .map(|tx| tx.data())
+                        .collect::<Vec<Transaction>>()
+                        .into(),
+                )
+                .uncles(
+                    uncles
+                        .into_iter()
+                        .map(|uncle| uncle.data())
+                        .collect::<Vec<UncleBlock>>()
+                        .into(),
+                )
                 .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 60e8067455..36370f22ae 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.pack())
+                        .cycles(cycles.into())
                         .transaction(tx.data())
                         .build()
                 })
diff --git a/sync/src/relayer/mod.rs b/sync/src/relayer/mod.rs
index 0a143e9770..9acd6ab82a 100644
--- a/sync/src/relayer/mod.rs
+++ b/sync/src/relayer/mod.rs
@@ -38,6 +38,7 @@ 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},
@@ -271,7 +272,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().pack())
+                .proposals(to_ask_proposals.clone().into())
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
             if !send_message_to(nc, peer, &message).is_ok() {
@@ -415,7 +416,7 @@ impl Relayer {
             .prefilled_transactions()
             .into_iter()
             .for_each(|pt| {
-                let index: usize = pt.index().unpack();
+                let index: usize = pt.index().into();
                 let gap = index - block_transactions.len();
                 if gap > 0 {
                     short_ids_iter
@@ -495,8 +496,13 @@ impl Relayer {
             let block = if let Some(extension) = compact_block.extension() {
                 packed::BlockV1::new_builder()
                     .header(compact_block.header())
-                    .uncles(uncles.pack())
-                    .transactions(txs.into_iter().map(|tx| tx.data()).pack())
+                    .uncles(uncles.into())
+                    .transactions(
+                        txs.into_iter()
+                            .map(|tx| tx.data())
+                            .collect::<Vec<Transaction>>()
+                            .into(),
+                    )
                     .proposals(compact_block.proposals())
                     .extension(extension)
                     .build()
@@ -504,8 +510,13 @@ impl Relayer {
             } else {
                 packed::Block::new_builder()
                     .header(compact_block.header())
-                    .uncles(uncles.pack())
-                    .transactions(txs.into_iter().map(|tx| tx.data()).pack())
+                    .uncles(uncles.into())
+                    .transactions(
+                        txs.into_iter()
+                            .map(|tx| tx.data())
+                            .collect::<Vec<Transaction>>()
+                            .into(),
+                    )
                     .proposals(compact_block.proposals())
                     .build()
             }
@@ -593,7 +604,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.into_iter().pack())
+                    .transactions(txs.into())
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
                 let status = send_message_to(nc, peer_index, &message);
@@ -639,7 +650,7 @@ impl Relayer {
                 );
                 tx_hashes.truncate(MAX_RELAY_TXS_NUM_PER_BATCH);
                 let content = packed::GetRelayTransactions::new_builder()
-                    .tx_hashes(tx_hashes.pack())
+                    .tx_hashes(tx_hashes.into())
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
                 let status = send_message_to(nc, peer, &message);
@@ -721,7 +732,7 @@ impl Relayer {
         }
         for (peer, hashes) in selected {
             let content = packed::RelayTransactionHashes::new_builder()
-                .tx_hashes(hashes.pack())
+                .tx_hashes(hashes.into())
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
 
diff --git a/sync/src/relayer/tests/block_proposal_process.rs b/sync/src/relayer/tests/block_proposal_process.rs
index e88ec876ad..bca97bcb0a 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};
+use ckb_types::packed::{self, ProposalShortId, Transaction};
 use ckb_types::prelude::*;
 
 #[test]
@@ -16,7 +16,13 @@ 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()).pack())
+        .transactions(
+            transactions
+                .into_iter()
+                .map(|tx| tx.data())
+                .collect::<Vec<Transaction>>()
+                .into(),
+        )
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
@@ -31,7 +37,13 @@ fn test_no_asked() {
     let transactions = vec![transaction.clone()];
 
     let content = packed::BlockProposal::new_builder()
-        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
+        .transactions(
+            transactions
+                .into_iter()
+                .map(|tx| tx.data())
+                .collect::<Vec<Transaction>>()
+                .into(),
+        )
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
@@ -60,7 +72,13 @@ fn test_ok() {
     }
 
     let content = packed::BlockProposal::new_builder()
-        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
+        .transactions(
+            transactions
+                .into_iter()
+                .map(|tx| tx.data())
+                .collect::<Vec<Transaction>>()
+                .into(),
+        )
         .build();
 
     let process = BlockProposalProcess::new(content.as_reader(), &relayer);
@@ -89,7 +107,13 @@ fn test_clear_expired_inflight_proposals() {
     }
 
     let content = packed::BlockProposal::new_builder()
-        .transactions(transactions.into_iter().map(|tx| tx.data()).pack())
+        .transactions(
+            transactions
+                .into_iter()
+                .map(|tx| tx.data())
+                .collect::<Vec<Transaction>>()
+                .into(),
+        )
         .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 8b106b7d3f..ad32e0c018 100644
--- a/sync/src/relayer/tests/block_transactions_process.rs
+++ b/sync/src/relayer/tests/block_transactions_process.rs
@@ -26,22 +26,24 @@ fn test_accept_block() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().pack())
+                .capacity(Capacity::bytes(1).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let tx3 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap().pack())
+                .capacity(Capacity::bytes(2).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
     let uncle = BlockBuilder::default()
-        .proposals(vec![tx3.proposal_short_id()].pack())
+        .proposals(Into::<packed::ProposalShortIdVec>::into(vec![
+            tx3.proposal_short_id()
+        ]))
         .build();
 
     let block = BlockBuilder::default()
@@ -70,8 +72,8 @@ fn test_accept_block() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].pack())
-        .uncles(vec![uncle.as_uncle().data()].pack())
+        .transactions(vec![tx2.data()].into())
+        .uncles(vec![uncle.as_uncle().data()].into())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -104,10 +106,10 @@ fn test_unknown_request() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().pack())
+                .capacity(Capacity::bytes(1).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let block = BlockBuilder::default()
@@ -133,7 +135,7 @@ fn test_unknown_request() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].pack())
+        .transactions(vec![tx2.data()].into())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -157,14 +159,14 @@ fn test_invalid_transaction_root() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().pack())
+                .capacity(Capacity::bytes(1).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let prefilled = IndexTransaction::new_builder()
-        .index(0u32.pack())
+        .index(0u32.into())
         .transaction(tx1.data())
         .build();
 
@@ -178,8 +180,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()].pack())
-        .prefilled_transactions(vec![prefilled].pack())
+        .short_ids(vec![tx2.proposal_short_id()].into())
+        .prefilled_transactions(vec![prefilled].into())
         .build();
 
     let block_hash = compact_block.header().calc_header_hash();
@@ -198,7 +200,7 @@ fn test_invalid_transaction_root() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block_hash)
-        .transactions(vec![tx2.data()].pack())
+        .transactions(vec![tx2.data()].into())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -234,19 +236,19 @@ fn test_collision_and_send_missing_indexes() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1000).unwrap().pack())
+                .capacity(Capacity::bytes(1000).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
     let tx3 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(last_cellbase.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap().pack())
+                .capacity(Capacity::bytes(2).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let fake_hash = tx3
@@ -294,7 +296,7 @@ fn test_collision_and_send_missing_indexes() {
 
     let block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].pack())
+        .transactions(vec![tx2.data()].into())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -313,7 +315,7 @@ fn test_collision_and_send_missing_indexes() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1u32, 2u32].pack())
+        .indexes([1u32, 2u32].into())
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let data = message.as_bytes();
@@ -337,7 +339,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()].pack())
+        .transactions(vec![tx2.data(), tx3.data()].into())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -370,18 +372,18 @@ fn test_missing() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().pack())
+                .capacity(Capacity::bytes(1).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
     let tx3 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap().pack())
+                .capacity(Capacity::bytes(2).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let block = BlockBuilder::default()
@@ -408,7 +410,7 @@ fn test_missing() {
 
     let block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].pack())
+        .transactions(vec![tx2.data()].into())
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -427,7 +429,7 @@ fn test_missing() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1, 2u32].pack())
+        .indexes([1, 2u32].into())
         .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 16d49ac962..485fe1573a 100644
--- a/sync/src/relayer/tests/block_transactions_verifier.rs
+++ b/sync/src/relayer/tests/block_transactions_verifier.rs
@@ -1,21 +1,25 @@
 use super::helper::new_index_transaction;
 use crate::relayer::block_transactions_verifier::BlockTransactionsVerifier;
 use crate::{Status, StatusCode};
-use ckb_types::packed::{CompactBlock, CompactBlockBuilder};
+use ckb_types::packed::{self, 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);
+    let prefilled_iter = vec![0, 2, 5]
+        .into_iter()
+        .map(new_index_transaction)
+        .collect::<Vec<packed::IndexTransaction>>();
 
     let short_ids = vec![1, 3, 4]
         .into_iter()
         .map(new_index_transaction)
-        .map(|tx| tx.transaction().proposal_short_id());
+        .map(|tx| tx.transaction().proposal_short_id())
+        .collect::<Vec<packed::ProposalShortId>>();
 
     CompactBlockBuilder::default()
-        .short_ids(short_ids.pack())
-        .prefilled_transactions(prefilled_iter.pack())
+        .short_ids(short_ids.into())
+        .prefilled_transactions(prefilled_iter.into())
         .build()
 }
 
diff --git a/sync/src/relayer/tests/compact_block.rs b/sync/src/relayer/tests/compact_block.rs
index 12845293f8..92ecaadb50 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.pack())
+            .index(0u32.into())
             .transaction(TransactionBuilder::default().build().data())
             .build(),
         IndexTransactionBuilder::default()
-            .index(2u32.pack())
+            .index(2u32.into())
             .transaction(TransactionBuilder::default().build().data())
             .build(),
     ];
 
     let compact_block = compact_block_builder
-        .short_ids(short_ids.into_iter().pack())
-        .prefilled_transactions(prefilled_transactions.into_iter().pack())
+        .short_ids(short_ids.into())
+        .prefilled_transactions(prefilled_transactions.into())
         .build();
 
     assert_eq!(
diff --git a/sync/src/relayer/tests/compact_block_process.rs b/sync/src/relayer/tests/compact_block_process.rs
index 3473b8e405..fca2194039 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.pack())
-                .epoch(EpochNumberWithFraction::new(1, 5, 1000).pack())
-                .timestamp(unix_time_as_millis().pack())
+                .number(5.into())
+                .epoch(EpochNumberWithFraction::new(1, 5, 1000).into())
+                .timestamp(unix_time_as_millis().into())
                 .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.pack())
+        .block_locator_hashes(locator_hash.into())
         .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.pack())
+        .number(4.into())
         .build();
 
     let block = BlockBuilder::default()
@@ -285,10 +285,10 @@ fn test_send_missing_indexes() {
             TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(Capacity::bytes(1).unwrap().pack())
+                        .capacity(Capacity::bytes(1).unwrap().into())
                         .build(),
                 )
-                .output_data(Bytes::new().pack())
+                .output_data(Bytes::new().into())
                 .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].pack())
-        .uncle_indexes([0u32].pack())
+        .indexes([1u32].into())
+        .uncle_indexes([0u32].into())
         .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].into_iter().pack())
+        .proposals(vec![proposal_id].into())
         .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.pack())
-        .epoch(EpochNumberWithFraction::new(1, 4, 1000).pack())
+        .number(4.into())
+        .epoch(EpochNumberWithFraction::new(1, 4, 1000).into())
         .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.pack()).build();
+    let mock_block_2 = block.as_advanced_builder().number(7.into()).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,11 +522,11 @@ fn test_collision() {
     let missing_tx = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1000).unwrap().pack())
+                .capacity(Capacity::bytes(1000).unwrap().into())
                 .build(),
         )
         .input(CellInput::new(OutPoint::new(last_cellbase.hash(), 0), 0))
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     let fake_hash = missing_tx
@@ -589,7 +589,7 @@ fn test_collision() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1u32].pack())
+        .indexes([1u32].into())
         .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 e0d7f3125d..4c0b9e686d 100644
--- a/sync/src/relayer/tests/compact_block_verifier.rs
+++ b/sync/src/relayer/tests/compact_block_verifier.rs
@@ -1,14 +1,17 @@
 use super::helper::new_index_transaction;
 use crate::relayer::compact_block_verifier::{PrefilledVerifier, ShortIdsVerifier};
 use crate::{Status, StatusCode};
-use ckb_types::packed::{CompactBlockBuilder, ProposalShortId};
+use ckb_types::packed::{self, 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);
+    let prefilled = vec![0, 1, 2, 4, 3]
+        .into_iter()
+        .map(new_index_transaction)
+        .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.pack())
+        .prefilled_transactions(prefilled.into())
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -18,18 +21,23 @@ fn test_unordered_prefilled() {
 
 #[test]
 fn test_ordered_prefilled() {
-    let prefilled = (0..5).map(new_index_transaction);
+    let prefilled = (0..5)
+        .map(new_index_transaction)
+        .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.pack())
+        .prefilled_transactions(prefilled.into())
         .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);
+    let prefilled = vec![0, 1, 2, 5]
+        .into_iter()
+        .map(new_index_transaction)
+        .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.pack())
+        .prefilled_transactions(prefilled.into())
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -45,9 +53,11 @@ fn test_cellbase_not_prefilled() {
         StatusCode::CompactBlockHasNotPrefilledCellbase.into(),
     );
 
-    let prefilled = (1..5).map(new_index_transaction);
+    let prefilled = (1..5)
+        .map(new_index_transaction)
+        .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.pack())
+        .prefilled_transactions(prefilled.into())
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -63,7 +73,7 @@ fn test_duplicated_short_ids() {
     short_ids.push(short_ids[0].clone());
 
     let block = CompactBlockBuilder::default()
-        .short_ids(short_ids.into_iter().pack())
+        .short_ids(short_ids.into())
         .build();
     assert_eq!(
         ShortIdsVerifier::verify(&block),
@@ -73,12 +83,16 @@ fn test_duplicated_short_ids() {
 
 #[test]
 fn test_intersected_short_ids() {
-    let prefilled = (0..=5).map(new_index_transaction);
-    let short_ids = (5..9).map(|i| new_index_transaction(i).transaction().proposal_short_id());
+    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 block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.pack())
-        .short_ids(short_ids.pack())
+        .prefilled_transactions(prefilled.into())
+        .short_ids(short_ids.into())
         .build();
     assert_eq!(
         ShortIdsVerifier::verify(&block),
@@ -88,13 +102,17 @@ fn test_intersected_short_ids() {
 
 #[test]
 fn test_normal() {
-    let prefilled = vec![1, 2, 5].into_iter().map(new_index_transaction);
+    let prefilled = vec![1, 2, 5]
+        .into_iter()
+        .map(new_index_transaction)
+        .collect::<Vec<packed::IndexTransaction>>();
     let short_ids = vec![0, 3, 4]
         .into_iter()
-        .map(|i| new_index_transaction(i).transaction().proposal_short_id());
+        .map(|i| new_index_transaction(i).transaction().proposal_short_id())
+        .collect::<Vec<packed::ProposalShortId>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.pack())
-        .short_ids(short_ids.pack())
+        .prefilled_transactions(prefilled.into())
+        .short_ids(short_ids.into())
         .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 568ba83dc7..55a9adda42 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].into_iter().pack())
+        .proposals(vec![id.clone(), id].into())
         .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 7f38edf5ad..9b206cdd50 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].pack())
+        .tx_hashes(vec![tx_hash.clone(), tx_hash].into())
         .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 a11ceb1fe8..6f7e562959 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().pack())
+                .capacity(Capacity::bytes(index).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build();
 
     IndexTransactionBuilder::default()
-        .index(index.pack())
+        .index(index.into())
         .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).pack())
-        .timestamp((parent.timestamp() + 1).pack())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-        .compact_target(epoch.compact_target().pack())
+        .number((parent.number() + 1).into())
+        .timestamp((parent.timestamp() + 1).into())
+        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+        .compact_target(epoch.compact_target().into())
 }
 
 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().pack()) // use capacity to identify transactions
+                .capacity(Capacity::bytes(500 + index).unwrap().into()) // use capacity to identify transactions
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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.pack())
+        .output_data(always_success_cell_data.into())
         .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().pack())
+            .timestamp(unix_time_as_millis().into())
             .dao(dao)
-            .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+            .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
             .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).pack())
+                    .capacity(capacity_bytes!(50000).into())
                     .lock(always_success_script.to_owned())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .witness(Script::default().into_witness())
             .build();
         let header = new_header_builder(&shared, &parent.header()).build();
@@ -277,18 +277,18 @@ pub(crate) fn gen_block(
                 .timestamp()
                 .checked_add_signed(timestamp_delta)
                 .unwrap())
-            .pack(),
+            .into(),
         )
-        .number(number.pack())
+        .number(number.into())
         .compact_target(
             (epoch
                 .compact_target()
                 .checked_add_signed(target_delta)
                 .unwrap())
-            .pack(),
+            .into(),
         )
         .dao(dao)
-        .epoch(epoch.number_with_fraction(number).pack())
+        .epoch(epoch.number_with_fraction(number).into())
         .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 a7e55ec1a7..303e48db32 100644
--- a/sync/src/relayer/tests/reconstruct_block.rs
+++ b/sync/src/relayer/tests/reconstruct_block.rs
@@ -20,9 +20,12 @@ 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());
+        let short_ids = prepare
+            .iter()
+            .map(|tx| tx.proposal_short_id())
+            .collect::<Vec<packed::ProposalShortId>>();
         let transactions: Vec<TransactionView> = prepare.iter().skip(1).cloned().collect();
-        let compact = compact_block_builder.short_ids(short_ids.pack()).build();
+        let compact = compact_block_builder.short_ids(short_ids.into()).build();
         assert_eq!(
             relayer.reconstruct_block(
                 &relayer.shared().active_chain(),
@@ -38,7 +41,10 @@ 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());
+        let short_ids = prepare
+            .iter()
+            .map(|tx| tx.proposal_short_id())
+            .collect::<Vec<packed::ProposalShortId>>();
         let transactions: Vec<TransactionView> =
             prepare.iter().skip(1).step_by(2).cloned().collect();
         let missing = prepare
@@ -47,7 +53,7 @@ fn test_missing_txs() {
             .step_by(2)
             .map(|(i, _)| i)
             .collect();
-        let compact = compact_block_builder.short_ids(short_ids.pack()).build();
+        let compact = compact_block_builder.short_ids(short_ids.into()).build();
         assert_eq!(
             relayer.reconstruct_block(
                 &relayer.shared().active_chain(),
@@ -104,7 +110,7 @@ fn test_reconstruct_transactions_and_uncles() {
 
     // BLOCK_VALID
     let ext = packed::BlockExtBuilder::default()
-        .verified(Some(true).pack())
+        .verified(Some(true).into())
         .build();
 
     let compact = packed::CompactBlock::build_from_block(&block, &prefilled);
@@ -127,7 +133,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.unpack()).unwrap();
+        db_txn.insert_block_ext(&uncle_hash, &ext.into()).unwrap();
         db_txn.commit().unwrap();
     }
     relayer.shared().shared().refresh_snapshot();
@@ -149,7 +155,7 @@ fn test_reconstruct_invalid_uncles() {
     let uncle = BlockBuilder::default().build();
     // BLOCK_VALID
     let ext = packed::BlockExtBuilder::default()
-        .verified(Some(false).pack())
+        .verified(Some(false).into())
         .build();
 
     let block = BlockBuilder::default()
@@ -163,7 +169,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.unpack()).unwrap();
+        db_txn.insert_block_ext(&uncle_hash, &ext.into()).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 11ad489500..146cb41be0 100644
--- a/sync/src/relayer/transactions_process.rs
+++ b/sync/src/relayer/transactions_process.rs
@@ -45,12 +45,7 @@ impl<'a> TransactionsProcess<'a> {
             self.message
                 .transactions()
                 .iter()
-                .map(|tx| {
-                    (
-                        tx.transaction().to_entity().into_view(),
-                        tx.cycles().unpack(),
-                    )
-                })
+                .map(|tx| (tx.transaction().to_entity().into_view(), tx.cycles().into()))
                 .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 12c5041413..cbb0738252 100644
--- a/sync/src/synchronizer/get_headers_process.rs
+++ b/sync/src/synchronizer/get_headers_process.rs
@@ -81,7 +81,13 @@ impl<'a> GetHeadersProcess<'a> {
             debug!("headers len={}", headers.len());
 
             let content = packed::SendHeaders::new_builder()
-                .headers(headers.into_iter().map(|x| x.data()).pack())
+                .headers(
+                    headers
+                        .into_iter()
+                        .map(|x| x.data())
+                        .collect::<Vec<packed::Header>>()
+                        .into(),
+                )
                 .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 83aa1213c3..8a18cc6973 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.pack()) {
+                match shared.header_map().get(&target.into()) {
                     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().pack())
+            .block_hashes(v_fetch.clone().into())
             .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().pack())
+            .block_hashes(v_fetch.clone().into())
             .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 4511a85821..6f793bfaa7 100644
--- a/sync/src/tests/inflight_blocks.rs
+++ b/sync/src/tests/inflight_blocks.rs
@@ -1,7 +1,6 @@
 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;
 
@@ -10,24 +9,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").pack()).into()));
-    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
+    assert!(inflight_blocks.insert(2.into(), (1, h256!("0x1").into()).into()));
+    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
 
     // peer 1 inflight
-    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").pack()).into()));
+    assert!(!inflight_blocks.insert(1.into(), (1, h256!("0x1").into()).into()));
 
-    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").pack()).into()));
+    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").into()).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").pack()).into()]))
+        Some(HashSet::from_iter(vec![(2, h256!("0x2").into()).into()]))
     );
 
     // receive block 0x1
-    inflight_blocks.remove_by_block((1, h256!("0x1").pack()).into());
+    inflight_blocks.remove_by_block((1, h256!("0x1").into()).into());
 
     assert_eq!(inflight_blocks.total_inflight_count(), 1); // 0x2
     assert_eq!(inflight_blocks.peer_inflight_count(1.into()), 1);
@@ -36,7 +35,7 @@ fn inflight_blocks_count() {
         inflight_blocks
             .inflight_block_by_peer(1.into())
             .map(|set| set.iter().collect()),
-        Some(vec![&(2, h256!("0x2").pack()).into()])
+        Some(vec![&(2, h256!("0x2").into()).into()])
     );
 }
 
@@ -44,19 +43,19 @@ fn inflight_blocks_count() {
 fn inflight_blocks_state() {
     let mut inflight_blocks = InflightBlocks::default();
 
-    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()));
+    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()));
 
     // peer 1 inflight
-    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(1.into(), (1, h256!("0x1").into()).into()));
+    assert!(inflight_blocks.insert(1.into(), (2, h256!("0x2").into()).into()));
 
-    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").pack()).into()));
+    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").into()).into()));
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(1, h256!("0x1").pack()).into())
+            .inflight_state_by_block(&(1, h256!("0x1").into()).into())
             .cloned()
             .map(|state| { state.peer }),
         Some(1.into())
@@ -64,7 +63,7 @@ fn inflight_blocks_state() {
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
+            .inflight_state_by_block(&(3, h256!("0x3").into()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
@@ -75,14 +74,14 @@ fn inflight_blocks_state() {
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(1, h256!("0x1").pack()).into())
+            .inflight_state_by_block(&(1, h256!("0x1").into()).into())
             .map(|state| state.peer),
         None
     );
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
+            .inflight_state_by_block(&(3, h256!("0x3").into()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
@@ -95,45 +94,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").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()));
+    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()));
 
     _faketime_guard.set_faketime(BLOCK_DOWNLOAD_TIMEOUT + 1);
 
-    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()));
+    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()));
 
     let peers = inflight_blocks.prune(0);
     assert_eq!(peers, HashSet::from_iter(vec![1.into()]));
-    assert!(inflight_blocks.insert(3.into(), (2, h256!("0x2").pack()).into()));
-    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").pack()).into()));
+    assert!(inflight_blocks.insert(3.into(), (2, h256!("0x2").into()).into()));
+    assert!(inflight_blocks.insert(3.into(), (3, h256!("0x3").into()).into()));
 
     assert_eq!(inflight_blocks.peer_can_fetch_count(2.into()), 32 >> 4);
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
+            .inflight_state_by_block(&(3, h256!("0x3").into()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(2, h256!("0x2").pack()).into())
+            .inflight_state_by_block(&(2, h256!("0x2").into()).into())
             .map(|state| state.peer),
         Some(3.into())
     );
 
     assert_eq!(
         inflight_blocks
-            .inflight_state_by_block(&(6, h256!("0x6").pack()).into())
+            .inflight_state_by_block(&(6, h256!("0x6").into()).into())
             .cloned()
             .map(|state| state.peer),
         Some(4.into())
@@ -148,13 +147,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").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()));
+    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()));
 
     let list = inflight_blocks.prune(2);
     assert!(list.is_empty());
@@ -172,10 +171,10 @@ fn inflight_trace_number_state() {
             .cloned()
             .collect::<HashSet<BlockNumberAndHash>>(),
         HashSet::from_iter(vec![
-            (1, h256!("0x1").pack()).into(),
-            (2, h256!("0x2").pack()).into(),
-            (3, h256!("0x3").pack()).into(),
-            (3, h256!("0x33").pack()).into()
+            (1, h256!("0x1").into()).into(),
+            (2, h256!("0x2").into()).into(),
+            (3, h256!("0x3").into()).into(),
+            (3, h256!("0x33").into()).into()
         ])
     );
 
@@ -187,10 +186,10 @@ fn inflight_trace_number_state() {
     assert!(inflight_blocks.restart_number == 3);
 
     assert!(inflight_blocks
-        .inflight_state_by_block(&(3, h256!("0x3").pack()).into())
+        .inflight_state_by_block(&(3, h256!("0x3").into()).into())
         .is_none());
     assert!(inflight_blocks
-        .inflight_state_by_block(&(3, h256!("0x33").pack()).into())
+        .inflight_state_by_block(&(3, h256!("0x33").into()).into())
         .is_none());
 
     assert_eq!(inflight_blocks.peer_can_fetch_count(3.into()), 32 >> 1);
diff --git a/sync/src/tests/orphan_block_pool.rs b/sync/src/tests/orphan_block_pool.rs
new file mode 100644
index 0000000000..c761ce89b1
--- /dev/null
+++ b/sync/src/tests/orphan_block_pool.rs
@@ -0,0 +1,152 @@
+use ckb_chain_spec::consensus::ConsensusBuilder;
+use ckb_systemtime::unix_time_as_millis;
+use ckb_types::core::{BlockBuilder, BlockView, EpochNumberWithFraction, HeaderView};
+use std::collections::HashSet;
+use std::sync::Arc;
+use std::thread;
+
+use crate::orphan_block_pool::OrphanBlockPool;
+
+fn gen_block(parent_header: &HeaderView) -> BlockView {
+    let number = parent_header.number() + 1;
+    BlockBuilder::default()
+        .parent_hash(parent_header.hash())
+        .timestamp(unix_time_as_millis().into())
+        .number(number.into())
+        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
+        .nonce((parent_header.nonce() + 1).into())
+        .build()
+}
+
+#[test]
+fn test_remove_blocks_by_parent() {
+    let consensus = ConsensusBuilder::default().build();
+    let block_number = 200;
+    let mut blocks = Vec::new();
+    let mut parent = consensus.genesis_block().header();
+    let pool = OrphanBlockPool::with_capacity(200);
+    let mut total_size = 0;
+    for _ in 1..block_number {
+        let new_block = gen_block(&parent);
+        total_size += new_block.data().total_size();
+        blocks.push(new_block.clone());
+        pool.insert(new_block.clone());
+        parent = new_block.header();
+    }
+    assert_eq!(total_size, pool.total_size());
+
+    let orphan = pool.remove_blocks_by_parent(&consensus.genesis_block().hash());
+    let orphan_set: HashSet<BlockView> = orphan.into_iter().collect();
+    let blocks_set: HashSet<BlockView> = blocks.into_iter().collect();
+    assert_eq!(orphan_set, blocks_set);
+    assert_eq!(0, pool.total_size());
+}
+
+#[test]
+fn test_remove_blocks_by_parent_and_get_block_should_not_deadlock() {
+    let consensus = ConsensusBuilder::default().build();
+    let pool = OrphanBlockPool::with_capacity(1024);
+    let mut header = consensus.genesis_block().header();
+    let mut hashes = Vec::new();
+    for _ in 1..1024 {
+        let new_block = gen_block(&header);
+        pool.insert(new_block.clone());
+        header = new_block.header();
+        hashes.push(header.hash());
+    }
+
+    let pool_arc1 = Arc::new(pool);
+    let pool_arc2 = Arc::clone(&pool_arc1);
+
+    let thread1 = thread::spawn(move || {
+        pool_arc1.remove_blocks_by_parent(&consensus.genesis_block().hash());
+    });
+
+    for hash in hashes.iter().rev() {
+        pool_arc2.get_block(hash);
+    }
+
+    thread1.join().unwrap();
+}
+
+#[test]
+fn test_leaders() {
+    let consensus = ConsensusBuilder::default().build();
+    let block_number = 20;
+    let mut blocks = Vec::new();
+    let mut parent = consensus.genesis_block().header();
+    let pool = OrphanBlockPool::with_capacity(20);
+    for i in 0..block_number - 1 {
+        let new_block = gen_block(&parent);
+        blocks.push(new_block.clone());
+        parent = new_block.header();
+        if i % 5 != 0 {
+            pool.insert(new_block.clone());
+        }
+    }
+
+    assert_eq!(pool.len(), 15);
+    assert_eq!(pool.leaders_len(), 4);
+
+    pool.insert(blocks[5].clone());
+    assert_eq!(pool.len(), 16);
+    assert_eq!(pool.leaders_len(), 3);
+
+    pool.insert(blocks[10].clone());
+    assert_eq!(pool.len(), 17);
+    assert_eq!(pool.leaders_len(), 2);
+
+    // index 0 doesn't in the orphan pool, so do nothing
+    let orphan = pool.remove_blocks_by_parent(&consensus.genesis_block().hash());
+    assert!(orphan.is_empty());
+    assert_eq!(pool.len(), 17);
+    assert_eq!(pool.leaders_len(), 2);
+
+    pool.insert(blocks[0].clone());
+    assert_eq!(pool.len(), 18);
+    assert_eq!(pool.leaders_len(), 2);
+
+    let orphan = pool.remove_blocks_by_parent(&consensus.genesis_block().hash());
+    assert_eq!(pool.len(), 3);
+    assert_eq!(pool.leaders_len(), 1);
+
+    pool.insert(blocks[15].clone());
+    assert_eq!(pool.len(), 4);
+    assert_eq!(pool.leaders_len(), 1);
+
+    let orphan_1 = pool.remove_blocks_by_parent(&blocks[14].hash());
+
+    let orphan_set: HashSet<BlockView> = orphan.into_iter().chain(orphan_1).collect();
+    let blocks_set: HashSet<BlockView> = blocks.into_iter().collect();
+    assert_eq!(orphan_set, blocks_set);
+    assert_eq!(pool.len(), 0);
+    assert_eq!(pool.leaders_len(), 0);
+}
+
+#[test]
+fn test_remove_expired_blocks() {
+    let consensus = ConsensusBuilder::default().build();
+    let block_number = 20;
+    let mut parent = consensus.genesis_block().header();
+    let pool = OrphanBlockPool::with_capacity(block_number);
+
+    let deprecated = EpochNumberWithFraction::new(10, 0, 10);
+
+    for _ in 1..block_number {
+        let new_block = BlockBuilder::default()
+            .parent_hash(parent.hash())
+            .timestamp(unix_time_as_millis().into())
+            .number((parent.number() + 1).into())
+            .epoch(deprecated.into())
+            .nonce((parent.nonce() + 1).into())
+            .build();
+        pool.insert(new_block.clone());
+        parent = new_block.header();
+    }
+    assert_eq!(pool.leaders_len(), 1);
+
+    let v = pool.clean_expired_blocks(20_u64);
+    assert_eq!(v.len(), 19);
+    assert_eq!(pool.leaders_len(), 0);
+    assert_eq!(pool.total_size(), 0)
+}
diff --git a/sync/src/tests/sync_shared.rs b/sync/src/tests/sync_shared.rs
index da9dea6e83..5e3826e8b5 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.pack())
+            .number(1000.into())
             .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).pack())
+            .timestamp((parent_header.timestamp() + 3).into())
             .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).pack())
+            .timestamp((parent_header.timestamp() + 3).into())
             .build();
         let arc_block = Arc::new(block.clone());
         assert!(fork_shared
diff --git a/sync/src/tests/synchronizer/basic_sync.rs b/sync/src/tests/synchronizer/basic_sync.rs
index 1eaa2c3bc9..188f2198cd 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.pack())
+        .output_data(always_success_cell_data.into())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx]).unwrap();
 
     let mut block = BlockBuilder::default()
-        .timestamp(unix_time_as_millis().pack())
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+        .timestamp(unix_time_as_millis().into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .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.pack())
+                        .capacity(reward.total.into())
                         .lock(always_success_script.to_owned())
                         .build(),
                 )
-                .output_data(Bytes::default().pack())
+                .output_data(Bytes::default().into())
                 .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().pack();
+        let bytes = chain_root.calc_mmr_hash().as_bytes().into();
 
         block = BlockBuilder::default()
             .transaction(cellbase)
             .parent_hash(block.header().hash())
-            .number(number.pack())
-            .epoch(epoch.number_with_fraction(number).pack())
-            .timestamp(timestamp.pack())
-            .compact_target(epoch.compact_target().pack())
+            .number(number.into())
+            .epoch(epoch.number_with_fraction(number).into())
+            .timestamp(timestamp.into())
+            .compact_target(epoch.compact_target().into())
             .dao(dao)
             .extension(Some(bytes))
             .build();
diff --git a/sync/src/tests/synchronizer/functions.rs b/sync/src/tests/synchronizer/functions.rs
index a63937d727..316d6a9c56 100644
--- a/sync/src/tests/synchronizer/functions.rs
+++ b/sync/src/tests/synchronizer/functions.rs
@@ -83,10 +83,10 @@ fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(reward.total.pack())
+                    .capacity(reward.total.into())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .build()
     }
 }
@@ -114,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().pack();
+    let bytes = chain_root.calc_mmr_hash().as_bytes().into();
 
     BlockBuilder::default()
         .transaction(cellbase)
         .parent_hash(parent_header.hash())
-        .timestamp(now.pack())
-        .epoch(epoch.number_with_fraction(number).pack())
-        .number(number.pack())
-        .compact_target(epoch.compact_target().pack())
-        .nonce(nonce.pack())
+        .timestamp(now.into())
+        .epoch(epoch.number_with_fraction(number).into())
+        .number(number.into())
+        .compact_target(epoch.compact_target().into())
+        .nonce(nonce.into())
         .dao(dao)
         .extension(Some(bytes))
         .build()
@@ -630,7 +630,13 @@ fn test_sync_process() {
     );
 
     let sendheaders = SendHeadersBuilder::default()
-        .headers(headers.iter().map(|h| h.data()).pack())
+        .headers(
+            headers
+                .iter()
+                .map(|h| h.data())
+                .collect::<Vec<packed::Header>>()
+                .into(),
+        )
         .build();
 
     let mock_nc = mock_network_context(4);
@@ -689,7 +695,13 @@ 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()).pack())
+        .headers(
+            headers
+                .iter()
+                .map(|h| h.data())
+                .collect::<Vec<packed::Header>>()
+                .into(),
+        )
         .build();
     assert_eq!(
         HeadersProcess::new(sendheaders.as_reader(), &synchronizer1, peer1, &mock_nc).execute(),
@@ -766,7 +778,7 @@ fn test_chain_sync_timeout() {
 
     let consensus = Consensus::default();
     let block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(3u64)).pack())
+        .compact_target(difficulty_to_compact(U256::from(3u64)).into())
         .transaction(consensus.genesis_block().transactions()[0].clone())
         .build();
     let consensus = ConsensusBuilder::default().genesis_block(block).build();
@@ -963,7 +975,7 @@ fn test_n_sync_started() {
 
     let consensus = Consensus::default();
     let block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(3u64)).pack())
+        .compact_target(difficulty_to_compact(U256::from(3u64)).into())
         .transaction(consensus.genesis_block().transactions()[0].clone())
         .build();
     let consensus = ConsensusBuilder::default().genesis_block(block).build();
@@ -1111,7 +1123,7 @@ fn test_fix_last_common_header() {
             .map(|block| block.header().data())
             .collect::<Vec<_>>();
         let sendheaders = SendHeadersBuilder::default()
-            .headers(fork_headers.pack())
+            .headers(fork_headers.into())
             .build();
         synchronizer.on_connected(&nc, peer);
         assert!(
@@ -1187,7 +1199,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].pack())
+        .block_hashes(vec![genesis_hash].into())
         .build();
 
     let nc = mock_network_context(1);
@@ -1200,7 +1212,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].pack())
+        .block_hashes(vec![hash.clone(), hash].into())
         .build();
 
     let nc = mock_network_context(1);
diff --git a/sync/src/tests/types.rs b/sync/src/tests/types.rs
index e41c0827d1..4fc1a2b657 100644
--- a/sync/src/tests/types.rs
+++ b/sync/src/tests/types.rs
@@ -2,7 +2,6 @@ use ckb_shared::types::HeaderIndexView;
 use ckb_types::{
     core::{BlockNumber, EpochNumberWithFraction, HeaderBuilder},
     packed::Byte32,
-    prelude::*,
     U256,
 };
 use rand::{thread_rng, Rng};
@@ -26,8 +25,8 @@ 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.pack())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack());
+            .number(number.into())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into());
         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 8f37b7e7bf..d59f9d4db9 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().pack();
+    let bytes = chain_root.calc_mmr_hash().as_bytes().into();
 
     BlockBuilder::default()
         .parent_hash(parent_hash.to_owned())
-        .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())
+        .number((parent.header().number() + 1).into())
+        .timestamp((parent.header().timestamp() + 1).into())
+        .epoch(epoch.number_with_fraction(parent_number + 1).into())
+        .compact_target(epoch.compact_target().into())
         .dao(dao)
         .transaction(cellbase)
         .extension(Some(bytes))
diff --git a/sync/src/types/mod.rs b/sync/src/types/mod.rs
index 476a5c308b..35fb940288 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.pack())
+            .block_locator_hashes(locator_hash.into())
             .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 229bf9bd3f..6825700c5a 100644
--- a/test/src/assertion/reward_assertion.rs
+++ b/test/src/assertion/reward_assertion.rs
@@ -1,7 +1,6 @@
 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) {
@@ -113,7 +112,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().unpack();
+            let capacity: u64 = output.capacity().into();
             self.cells_capacity.insert(out_point, capacity);
         }
 
diff --git a/test/src/node.rs b/test/src/node.rs
index ad25d7fe89..f07668c811 100644
--- a/test/src/node.rs
+++ b/test/src/node.rs
@@ -368,7 +368,7 @@ impl Node {
         let timestamp = block.timestamp();
         let uncle = block
             .as_advanced_builder()
-            .timestamp((timestamp - 1).pack())
+            .timestamp((timestamp - 1).into())
             .build();
         (block, uncle)
     }
@@ -404,7 +404,7 @@ impl Node {
         let res = self
             .rpc_client()
             .send_transaction_result(transaction.data().into())?
-            .pack();
+            .into();
         Ok(res)
     }
 
@@ -596,7 +596,7 @@ impl Node {
             .cell_dep(always_success_cell_dep)
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity.pack())
+                    .capacity(capacity.into())
                     .lock(always_success_script)
                     .build(),
             )
@@ -622,7 +622,7 @@ impl Node {
             .cell_dep(always_failure_cell_dep)
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100).pack())
+                    .capacity(capacity_bytes!(100).into())
                     .lock(always_failure_script)
                     .build(),
             )
diff --git a/test/src/rpc.rs b/test/src/rpc.rs
index bb4b9a81dc..e1634141f4 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, prelude::*, H256};
+use ckb_types::{packed::Byte32, 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.unpack())
+            .get_block(hash.into())
             .expect("rpc call get_block")
     }
 
     pub fn get_fork_block(&self, hash: Byte32) -> Option<BlockView> {
         self.inner
-            .get_fork_block(hash.unpack())
+            .get_fork_block(hash.into())
             .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.unpack())
+            .get_header(hash.into())
             .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.unpack())
+            .get_block_filter(hash.into())
             .expect("rpc call get_block_filter")
     }
 
@@ -86,13 +86,13 @@ impl RpcClient {
         verbosity: u32,
     ) -> TransactionWithStatusResponse {
         self.inner
-            .get_transaction(hash.unpack(), Some(verbosity.into()), None)
+            .get_transaction(hash.into(), 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.unpack())
+            .get_pool_tx_detail_info(hash.into())
             .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.pack())
+            .map(|x| x.into())
     }
 
     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.pack())
+        self.inner.submit_block(work_id, block).map(|x| x.into())
     }
 
     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.unpack())
+            .get_block_median_time(block_hash.into())
             .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")
-            .pack()
+            .into()
     }
 
     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.unpack())
+            .remove_transaction(tx_hash.into())
             .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.pack())
+            .map(|x| x.into())
     }
 
     pub fn truncate(&self, target_tip_hash: Byte32) {
         self.inner()
-            .truncate(target_tip_hash.unpack())
+            .truncate(target_tip_hash.into())
             .expect("rpc call truncate")
     }
 
@@ -290,14 +290,14 @@ impl RpcClient {
         self.inner()
             .generate_block()
             .expect("rpc call generate_block")
-            .pack()
+            .into()
     }
 
     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")
-            .pack()
+            .into()
     }
 
     pub fn calculate_dao_maximum_withdraw(
@@ -306,14 +306,14 @@ impl RpcClient {
         hash: Byte32,
     ) -> CoreCapacity {
         self.inner()
-            .calculate_dao_maximum_withdraw(out_point, hash.unpack())
+            .calculate_dao_maximum_withdraw(out_point, hash.into())
             .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.unpack())
+            .get_block_economic_state(hash.into())
             .expect("rpc call get_block_economic_state")
     }
 
@@ -321,7 +321,7 @@ impl RpcClient {
         self.inner()
             .notify_transaction(tx)
             .expect("rpc call send_transaction")
-            .pack()
+            .into()
     }
 
     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 d5e8164753..027cfd9574 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.pack())
-            .message(warning1.pack())
-            .notice_until(notice_until.pack())
+            .id(id1.into())
+            .message((&warning1).into())
+            .notice_until(notice_until.into())
             .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.pack())
-            .cancel(id1.pack())
-            .message(warning2.pack())
-            .notice_until(notice_until.pack())
+            .id(id2.into())
+            .cancel(id1.into())
+            .message((&warning2).into())
+            .notice_until(notice_until.into())
             .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().unpack();
+    let msg: Message = raw_alert.calc_alert_hash().into();
     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.pack()
+            data.into()
         })
         .collect::<Vec<packed::Bytes>>();
     Alert::new_builder()
         .raw(raw_alert)
-        .signatures(signatures.pack())
+        .signatures(signatures.into())
         .build()
 }
diff --git a/test/src/specs/consensus/insufficient_reward.rs b/test/src/specs/consensus/insufficient_reward.rs
index 45d1e6bf3d..0c0c9042b5 100644
--- a/test/src/specs/consensus/insufficient_reward.rs
+++ b/test/src/specs/consensus/insufficient_reward.rs
@@ -46,7 +46,7 @@ impl Spec for InsufficientReward {
 
         // build a block with insufficient reward
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(1).pack())
+            .capacity(capacity_bytes!(1).into())
             .lock(Default::default())
             .build();
         let cellbase = new_block_builder.clone().build().transactions()[0]
diff --git a/test/src/specs/dao/dao_tx.rs b/test/src/specs/dao/dao_tx.rs
index 64eec88332..9bed9be765 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().unpack(),
+            withdrawal.inputs().get(0).unwrap().since().into(),
         );
         goto_target_point(node, since);
         ensure_committed(node, &withdrawal);
@@ -59,11 +59,11 @@ impl Spec for WithdrawDAOWithOverflowCapacity {
                 .outputs()
                 .into_iter()
                 .map(|cell_output| {
-                    let old_capacity: Capacity = cell_output.capacity().unpack();
+                    let old_capacity: Capacity = cell_output.capacity().into();
                     let new_capacity = old_capacity.safe_add(Capacity::one()).unwrap();
                     cell_output
                         .as_builder()
-                        .capacity(new_capacity.pack())
+                        .capacity(new_capacity.into())
                         .build()
                 })
                 .collect();
@@ -73,7 +73,7 @@ impl Spec for WithdrawDAOWithOverflowCapacity {
                 .build()
         };
         let since = EpochNumberWithFraction::from_full_value(
-            withdrawal.inputs().get(0).unwrap().since().unpack(),
+            withdrawal.inputs().get(0).unwrap().since().into(),
         );
         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 aa729e8476..4f9587c16a 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::WitnessArgs;
+use ckb_types::packed::{self, 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 = Bytes::from(&[0u8; 8][..]).pack();
+        let output_data: packed::Bytes = Bytes::from(&[0u8; 8][..]).into();
         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.pack())
+                        .capacity(capacity.into())
                         .lock(node.always_success_script())
-                        .type_(Some(self.dao_type_script()).pack())
+                        .type_(Some(self.dao_type_script()).into())
                         .build()
                 })
                 .collect::<Vec<_>>()
@@ -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().pack())
+                .capacity(txo.capacity().into())
                 .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()).pack()
+            Bytes::from(deposit_number.to_le_bytes().to_vec()).into()
         });
         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())).pack())
+                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())).into())
                     .build()
                     .as_bytes()
-                    .pack()
+                    .into()
             })
             .collect::<Vec<_>>();
         let tx = TransactionBuilder::default()
@@ -148,7 +148,7 @@ impl<'a> DAOUser<'a> {
             })
             .sum::<u64>();
         let output = CellOutput::new_builder()
-            .capacity(output_capacity.pack())
+            .capacity(output_capacity.into())
             .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())).pack())
+                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())).into())
                     .build()
                     .as_bytes()
-                    .pack()
+                    .into()
             })
             .collect::<Vec<_>>();
         let tx = TransactionBuilder::default()
@@ -220,7 +220,7 @@ impl<'a> DAOUser<'a> {
                 let header = self
                     .node
                     .rpc_client()
-                    .get_header(block_hash.pack())
+                    .get_header(block_hash.into())
                     .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.pack())
+                .get_header(deposit_hash.into())
                 .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 b2b1fab86a..989a321180 100644
--- a/test/src/specs/dao/dao_verifier.rs
+++ b/test/src/specs/dao/dao_verifier.rs
@@ -5,7 +5,6 @@ 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;
 
@@ -148,7 +147,7 @@ impl DAOVerifier {
                     && tx_index == 0
                     && output.lock().args().raw_data() == satoshi_pubkey_hash.0[..]
                 {
-                    sum += Unpack::<Capacity>::unpack(&output.capacity())
+                    sum += Into::<Capacity>::into(&output.capacity())
                         .safe_mul_ratio(satoshi_cell_occupied_ratio)
                         .unwrap()
                         .as_u64();
@@ -219,7 +218,7 @@ impl DAOVerifier {
                     let prepare_tx = self.get_transaction(&o.tx_hash());
                     let deposit_out_point = prepare_tx
                         .inputs()
-                        .get(o.index().unpack())
+                        .get(o.index().into())
                         .unwrap()
                         .previous_output();
                     let deposit_header_number =
@@ -246,7 +245,7 @@ impl DAOVerifier {
         let input_tx = self.get_transaction(&out_point.tx_hash());
         let input_data = input_tx
             .outputs_data()
-            .get(out_point.index().unpack())
+            .get(out_point.index().into())
             .unwrap();
         if input_data.len() != 8 {
             return false;
@@ -333,12 +332,12 @@ impl DAOVerifier {
 
     fn get_output(&self, out_point: &OutPoint) -> CellOutput {
         self.get_transaction(&out_point.tx_hash())
-            .output(out_point.index().unpack())
+            .output(out_point.index().into())
             .expect("exist")
     }
 
     fn get_output_capacity(&self, out_point: &OutPoint) -> u64 {
-        self.get_output(out_point).capacity().unpack()
+        self.get_output(out_point).capacity().into()
     }
 
     fn get_output_occupied_capacity(&self, out_point: &OutPoint) -> u64 {
@@ -346,12 +345,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().unpack())
+            .output_with_data(out_point.index().into())
             .expect("exist");
-        if Unpack::<u32>::unpack(&out_point.index()) == 0
+        if Into::<u32>::into(&out_point.index()) == 0
             && output.lock().args().raw_data() == satoshi_pubkey_hash.0[..]
         {
-            Unpack::<Capacity>::unpack(&output.capacity())
+            Into::<Capacity>::into(&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 5756d25ceb..6fb8965cea 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().unpack(),
+            withdrawal.inputs().get(0).unwrap().since().into(),
         );
         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.pack())
+            .capacity(satoshi_cell_occupied.into())
             .lock(always_success_cell().2.clone())
             .build();
 
@@ -103,19 +103,19 @@ impl Spec for SpendSatoshiCell {
             .cell_deps(vec![node0.always_success_cell_dep()])
             .input(satoshi_input)
             .output(output)
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .build();
         let tx_hash = transaction.hash();
         let sig = self
             .privkey
-            .sign_recoverable(&tx_hash.unpack())
+            .sign_recoverable(&(&tx_hash).into())
             .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.pack())
+            .witness(witness.into())
             .build();
 
         node0.mine(1);
@@ -152,7 +152,7 @@ fn issue_satoshi_cell() -> IssuedCell {
         .2
         .clone()
         .as_builder()
-        .args(Bytes::from(&SATOSHI_PUBKEY_HASH.0[..]).pack())
+        .args(Bytes::from(&SATOSHI_PUBKEY_HASH.0[..]).into())
         .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 929a2e2f54..801c12650c 100644
--- a/test/src/specs/hardfork/v2021/cell_deps.rs
+++ b/test/src/specs/hardfork/v2021/cell_deps.rs
@@ -219,7 +219,7 @@ impl NewScript {
         };
         let cell_input = inputs.next().unwrap();
         let cell_output = packed::CellOutput::new_builder()
-            .type_(Some(type_script).pack())
+            .type_(Some(type_script).into())
             .build_exact_capacity(core::Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -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.unpack());
+            .new_block_with_blocking(|template| template.parent_hash != (&block_hash).into());
     }
 }
 
@@ -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)).pack())
+            .type_(Some(type_script.as_data_script(0)).into())
             .build_exact_capacity(core::Capacity::bytes(data_script.data().len()).unwrap())
             .unwrap();
         let tx = TransactionView::new_advanced_builder()
@@ -469,13 +469,14 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         inputs: &mut impl Iterator<Item = packed::CellInput>,
         dep_txs: &[&TransactionView],
     ) -> packed::CellDep {
-        let dep_data = dep_txs
-            .iter()
-            .map(|tx| packed::OutPoint::new(tx.hash(), 0))
-            .collect::<Vec<_>>()
-            .pack()
-            .as_bytes()
-            .pack();
+        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_output = packed::CellOutput::new_builder()
             .build_exact_capacity(core::Capacity::bytes(dep_data.len()).unwrap())
             .unwrap();
@@ -503,7 +504,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().unpack();
+        let previous_output_index: usize = previous_output.index().into();
         if let Either::Left(tx) = self
             .node
             .rpc_client()
@@ -525,7 +526,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().pack())
+            .capacity(input_cell.capacity.value().into())
             .lock(new_script.as_data_script(0))
             .build();
         let tx = TransactionView::new_advanced_builder()
@@ -545,9 +546,9 @@ 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().pack())
+            .capacity(input_cell.capacity.value().into())
             .lock(self.node.always_success_script())
-            .type_(Some(new_script.as_data_script(0)).pack())
+            .type_(Some(new_script.as_data_script(0)).into())
             .build();
         let tx = TransactionView::new_advanced_builder()
             .cell_dep(self.node.always_success_cell_dep())
@@ -566,7 +567,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().pack())
+            .capacity(input_cell.capacity.value().into())
             .lock(new_script.as_type_script())
             .build();
         let tx = TransactionView::new_advanced_builder()
@@ -586,9 +587,9 @@ 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().pack())
+            .capacity(input_cell.capacity.value().into())
             .lock(self.node.always_success_script())
-            .type_(Some(new_script.as_type_script()).pack())
+            .type_(Some(new_script.as_type_script()).into())
             .build();
         let tx = TransactionView::new_advanced_builder()
             .cell_dep(self.node.always_success_cell_dep())
@@ -626,11 +627,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)).pack()),
+                        .type_(Some(new_script.as_data_script(0)).into()),
                     (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()).pack()),
+                        .type_(Some(new_script.as_type_script()).into()),
                 }
             }
         }
diff --git a/test/src/specs/hardfork/v2021/vm_b_extension.rs b/test/src/specs/hardfork/v2021/vm_b_extension.rs
index 22882c4140..d03ac41f50 100644
--- a/test/src/specs/hardfork/v2021/vm_b_extension.rs
+++ b/test/src/specs/hardfork/v2021/vm_b_extension.rs
@@ -80,7 +80,7 @@ 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").pack();
+        let data: packed::Bytes = include_bytes!("../../../../../script/testdata/cpop_lock").into();
         let tx = Self::deploy(node, &data, cell_input);
         let cell_dep = packed::CellDep::new_builder()
             .out_point(packed::OutPoint::new(tx.hash(), 0))
@@ -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).pack())
+            .type_(Some(type_script).into())
             .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -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.pack()
+                vec.into()
             };
             let script = self.script.as_script(vm_opt, args);
             packed::CellOutput::new_builder()
                 .lock(self.node.always_success_script())
-                .type_(Some(script).pack())
+                .type_(Some(script).into())
                 .build_exact_capacity(Capacity::shannons(0))
                 .unwrap()
         };
diff --git a/test/src/specs/hardfork/v2021/vm_version1.rs b/test/src/specs/hardfork/v2021/vm_version1.rs
index f49d955275..53911c67a6 100644
--- a/test/src/specs/hardfork/v2021/vm_version1.rs
+++ b/test/src/specs/hardfork/v2021/vm_version1.rs
@@ -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).pack())
+            .type_(Some(type_script).into())
             .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -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).pack()),
+                    .type_(Some(script).into()),
             )
         } else {
             (
@@ -229,7 +229,7 @@ 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).pack())
+            .capacity((input_cell.capacity.value() - 1).into())
             .build();
         let tx = tx_builder
             .cell_dep(self.node.always_success_cell_dep())
@@ -277,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().unpack();
+        let previous_output_index: usize = previous_output.index().into();
         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 972fb74f9e..f28e4dd4c4 100644
--- a/test/src/specs/hardfork/v2023/vm_version2.rs
+++ b/test/src/specs/hardfork/v2023/vm_version2.rs
@@ -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).pack())
+            .type_(Some(type_script).into())
             .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
             .unwrap();
         let tx = tx_template
@@ -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).pack()),
+                    .type_(Some(script).into()),
             )
         } else {
             (
@@ -250,7 +250,7 @@ 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).pack())
+            .capacity((input_cell.capacity.value() - 1).into())
             .build();
         let tx = tx_builder
             .cell_dep(self.node.always_success_cell_dep())
@@ -298,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().unpack();
+        let previous_output_index: usize = previous_output.index().into();
 
         if let Either::Left(tx) = self
             .node
diff --git a/test/src/specs/mining/basic.rs b/test/src/specs/mining/basic.rs
index c08357e5b5..f78ec326c6 100644
--- a/test/src/specs/mining/basic.rs
+++ b/test/src/specs/mining/basic.rs
@@ -3,7 +3,6 @@ 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;
 
@@ -50,7 +49,7 @@ impl Spec for BlockTemplates {
                 block1
                     .header()
                     .as_advanced_builder()
-                    .timestamp((block1.header().timestamp() + 1).pack())
+                    .timestamp((block1.header().timestamp() + 1).into())
                     .build(),
             )
             .build();
@@ -61,13 +60,13 @@ impl Spec for BlockTemplates {
         node.submit_block(&block2);
         assert_eq!(
             block1.hash(),
-            rpc_client.get_tip_header().hash.pack(),
+            rpc_client.get_tip_header().hash.into(),
             "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.pack(),
+            (&template1.parent_hash).into(),
             "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 0bf13bbfcd..861f718abd 100644
--- a/test/src/specs/mining/bootstrap.rs
+++ b/test/src/specs/mining/bootstrap.rs
@@ -20,8 +20,8 @@ impl Spec for BootstrapCellbase {
         node.mine(DEFAULT_TX_PROPOSAL_WINDOW.1 + 1);
 
         let miner = packed::Script::new_builder()
-            .args(Bytes::from(vec![2, 1]).pack())
-            .code_hash(h256!("0xa2").pack())
+            .args(Bytes::from(vec![2, 1]).into())
+            .code_hash(h256!("0xa2").into())
             .hash_type(ScriptHashType::Data.into())
             .build();
 
diff --git a/test/src/specs/mining/fee.rs b/test/src/specs/mining/fee.rs
index abadc4daf8..c9cb84afb4 100644
--- a/test/src/specs/mining/fee.rs
+++ b/test/src/specs/mining/fee.rs
@@ -79,7 +79,7 @@ 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.pack())
+                    .capacity(random_capacity.into())
                     .lock(cell.cell_output.lock())
                     .type_(cell.cell_output.type_())
                     .build();
@@ -135,7 +135,7 @@ 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.pack())
+                    .capacity(random_capacity.into())
                     .lock(cell.cell_output.lock())
                     .type_(cell.cell_output.type_())
                     .build();
@@ -225,7 +225,7 @@ impl Spec for ProposeDuplicated {
             let uncle = node
                 .new_block_builder(None, None, None)
                 .proposal(tx.proposal_short_id())
-                .nonce(99999.pack())
+                .nonce(99999.into())
                 .build()
                 .as_uncle();
             node.mine(1);
@@ -256,7 +256,7 @@ impl Spec for MalformedTx {
         let tx0 = node0.new_transaction_spend_tip_cellbase();
 
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(1000).pack())
+            .capacity(capacity_bytes!(1000).into())
             .build();
 
         let child = tx0
diff --git a/test/src/specs/mining/proposal.rs b/test/src/specs/mining/proposal.rs
index 272252671c..5a29009c77 100644
--- a/test/src/specs/mining/proposal.rs
+++ b/test/src/specs/mining/proposal.rs
@@ -2,7 +2,6 @@ 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;
 
@@ -21,7 +20,7 @@ impl Spec for AvoidDuplicatedProposalsWithUncles {
             let block = node.new_block(None, None, None);
             let uncle = block
                 .as_advanced_builder()
-                .timestamp((block.timestamp() + 1).pack())
+                .timestamp((block.timestamp() + 1).into())
                 .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 04d044421f..9ef25609bc 100644
--- a/test/src/specs/mining/uncle.rs
+++ b/test/src/specs/mining/uncle.rs
@@ -1,6 +1,5 @@
 use crate::{Node, Spec};
 use ckb_types::core::{BlockView, EpochNumberWithFraction};
-use ckb_types::prelude::*;
 
 // Convention:
 //   main-block: a block on the main fork
@@ -86,9 +85,9 @@ impl Spec for UncleInheritFromForkUncle {
 
         let uncle_child = uncle_parent
             .as_advanced_builder()
-            .number((uncle_parent.number() + 1).pack())
+            .number((uncle_parent.number() + 1).into())
             .parent_hash(uncle_parent.hash())
-            .timestamp((uncle_parent.timestamp() + 1).pack())
+            .timestamp((uncle_parent.timestamp() + 1).into())
             .epoch(
                 {
                     let parent_epoch = uncle_parent.epoch();
@@ -97,7 +96,7 @@ impl Spec for UncleInheritFromForkUncle {
                     let epoch_length = parent_epoch.length();
                     EpochNumberWithFraction::new(epoch_number, epoch_index + 1, epoch_length)
                 }
-                .pack(),
+                .into(),
             )
             .build();
 
diff --git a/test/src/specs/relay/block_relay.rs b/test/src/specs/relay/block_relay.rs
index 22569ce61e..1f5b5a2efb 100644
--- a/test/src/specs/relay/block_relay.rs
+++ b/test/src/specs/relay/block_relay.rs
@@ -3,7 +3,6 @@ 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;
@@ -22,7 +21,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).pack())
+            .timestamp((now_ms() + future).into())
             .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 9b8c078b7f..ab2b70a2c7 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").pack())
+                    .parent_hash(h256!("0x123456").into())
                     .build(),
             )
             .build();
@@ -297,7 +297,7 @@ impl Spec for CompactBlockMissingWithDropTx {
                             .as_reader()
                             .indexes()
                             .iter()
-                            .map(|i| Unpack::<u32>::unpack(&i))
+                            .map(Into::<u32>::into)
                             .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()].pack())
+            .transactions(vec![new_tx_2.data()].into())
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
 
@@ -331,7 +331,7 @@ impl Spec for CompactBlockMissingWithDropTx {
                             .as_reader()
                             .indexes()
                             .iter()
-                            .map(|i| Unpack::<u32>::unpack(&i))
+                            .map(Into::<u32>::into)
                             .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()].pack())
+            .transactions(vec![new_tx_1.data(), new_tx_2.data()].into())
             .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 f3e59b45e1..b076b37666 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.pack())
+            .proposals(proposal_ids.into())
             .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 e621ad336d..d36fd6b579 100644
--- a/test/src/specs/relay/get_block_transactions_process.rs
+++ b/test/src/specs/relay/get_block_transactions_process.rs
@@ -24,21 +24,21 @@ impl Spec for MissingUncleRequest {
         node.mine(1);
 
         let builder = node.new_block_builder(None, None, None);
-        let block1 = builder.clone().nonce(0.pack()).build();
-        let block2 = builder.nonce(1.pack()).build();
+        let block1 = builder.clone().nonce(0.into()).build();
+        let block2 = builder.nonce(1.into()).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.pack())
+            .nonce(0.into())
             .build();
         node.submit_block(&block);
 
         let content = packed::GetBlockTransactions::new_builder()
             .block_hash(block.hash())
-            .uncle_indexes([0u32].pack())
+            .uncle_indexes([0u32].into())
             .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 1a9512314c..46c7597216 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).pack())
+            .capacity(capacity_bytes!(80).into())
             .build();
 
         let tx2 = tx2_temp
diff --git a/test/src/specs/rpc/get_block_template.rs b/test/src/specs/rpc/get_block_template.rs
index 58a076e117..46c509b44d 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::prelude::*;
+use ckb_types::packed;
 
 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.pack(),
+            (&genesis_block_template.parent_hash).into(),
             "Parent block hash should be {}, but got {}",
             parent_block_hash,
-            genesis_block_template.parent_hash.pack()
+            Into::<packed::Byte32>::into(&genesis_block_template.parent_hash)
         );
         assert_eq!(
             0,
diff --git a/test/src/specs/rpc/submit_block.rs b/test/src/specs/rpc/submit_block.rs
index 6a06fa8025..adfa9ae399 100644
--- a/test/src/specs/rpc/submit_block.rs
+++ b/test/src/specs/rpc/submit_block.rs
@@ -1,9 +1,6 @@
 use crate::utils::now_ms;
 use crate::{Node, Spec};
-use ckb_types::{
-    core::{EpochNumberWithFraction, HeaderView},
-    prelude::*,
-};
+use ckb_types::core::{EpochNumberWithFraction, HeaderView};
 
 pub struct RpcSubmitBlock;
 
@@ -19,7 +16,7 @@ impl Spec for RpcSubmitBlock {
         // build block with wrong block number
         let block = node0
             .new_block_builder(None, None, None)
-            .number(2.pack())
+            .number(2.into())
             .build();
         let block_err = node0
             .rpc_client()
@@ -41,7 +38,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.pack())
+            .epoch(epoch.into())
             .build();
         let block_err = node0
             .rpc_client()
@@ -87,7 +84,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).pack())
+            .timestamp((now_ms() + 30_000).into())
             .build();
         let block_err = node0
             .rpc_client()
@@ -102,7 +99,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).pack())
+            .timestamp((median_time - 1).into())
             .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 0b5d83384e..d4eefcb4c4 100644
--- a/test/src/specs/rpc/transaction_proof.rs
+++ b/test/src/specs/rpc/transaction_proof.rs
@@ -1,5 +1,4 @@
 use crate::{Node, Spec, DEFAULT_TX_PROPOSAL_WINDOW};
-use ckb_types::prelude::*;
 
 pub struct RpcTransactionProof;
 
@@ -10,7 +9,7 @@ impl Spec for RpcTransactionProof {
 
         let tx_hash = node0.generate_transaction();
         node0.mine_until_transaction_confirm(&tx_hash);
-        let tx_hashes = vec![tx_hash.unpack()];
+        let tx_hashes = vec![tx_hash.into()];
         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 0996da7935..cc4f85d83b 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.pack())
+                .start_number(start_number.into())
                 .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().unpack();
+                    let resp_start_number: u64 = reader.start_number().into();
                     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.pack())
+                .start_number(start_number.into())
                 .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().unpack();
+                    let resp_start_number: u64 = reader.start_number().into();
                     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.pack())
+                .start_number(start_number.into())
                 .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().unpack();
+                    let resp_start_number: u64 = reader.start_number().into();
                     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().unpack())
+                        .map(|item| item.to_entity().into())
                         .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.pack())
+                .start_number(start_number.into())
                 .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().unpack();
+                    let resp_start_number: u64 = reader.start_number().into();
                     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().unpack())
+                        .map(|item| item.to_entity().into())
                         .collect();
 
                     assert_eq!(
diff --git a/test/src/specs/sync/block_sync.rs b/test/src/specs/sync/block_sync.rs
index 10f2ef9ffe..77232ab300 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.pack()).build();
-        let new_block2 = new_builder.nonce(1.pack()).build();
+        let new_block1 = new_builder.clone().nonce(0.into()).build();
+        let new_block2 = new_builder.nonce(1.into()).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).pack())
+            .timestamp((a.timestamp() + 1).into())
             .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).pack())
+                .timestamp((now_ms() + future).into())
                 .build();
 
             // node1 sync node1 with too new block
@@ -472,7 +472,7 @@ impl Spec for HeaderSyncCycle {
         net.connect(node0);
 
         let send_headers = SendHeaders::new_builder()
-            .headers(Vec::new().pack())
+            .headers(Vec::new().into())
             .build();
 
         let msg = SyncMessage::new_builder()
diff --git a/test/src/specs/sync/chain_forks.rs b/test/src/specs/sync/chain_forks.rs
index b1d9132f6c..d7c777b904 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().unpack();
+            let old_capacity: Capacity = old_output.capacity().into();
             let new_output = old_output
                 .as_builder()
-                .capacity(old_capacity.safe_add(capacity_bytes!(1)).unwrap().pack())
+                .capacity(old_capacity.safe_add(capacity_bytes!(1)).unwrap().into())
                 .build();
             transaction
                 .as_advanced_builder()
@@ -214,7 +214,7 @@ impl Spec for ChainFork4 {
                 .unwrap()
                 .to_entity()
                 .as_builder()
-                .capacity(capacity_bytes!(1).pack())
+                .capacity(capacity_bytes!(1).into())
                 .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").pack());
+        let invalid_transaction = node1.new_transaction(h256!("0x1").into());
         let invalid_block = block
             .as_advanced_builder()
             .transaction(invalid_transaction)
@@ -405,7 +405,7 @@ impl Spec for ChainFork7 {
         let previous_output = input
             .previous_output()
             .as_builder()
-            .index(999u32.pack())
+            .index(999u32.into())
             .build();
         let input = input.as_builder().previous_output(previous_output).build();
         let invalid_transaction = transaction
@@ -576,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).pack())
+            .timestamp((block_a.timestamp() + 2).into())
             .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 e11262ca30..44af4a7143 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").pack())
+            .map(|_| h256!("0x1").into())
             .collect();
 
         let message = SyncMessage::new_builder()
             .set(
                 GetHeaders::new_builder()
-                    .block_locator_hashes(hashes.pack())
+                    .block_locator_hashes(hashes.into())
                     .build(),
             )
             .build()
diff --git a/test/src/specs/tx_pool/collision.rs b/test/src/specs/tx_pool/collision.rs
index 0d93697c03..3a870e7328 100644
--- a/test/src/specs/tx_pool/collision.rs
+++ b/test/src/specs/tx_pool/collision.rs
@@ -194,7 +194,7 @@ fn conflict_transactions_with_capacity(
         .unwrap();
     let txb = txa
         .as_advanced_builder()
-        .set_outputs_data(vec![output_data.pack()])
+        .set_outputs_data(vec![output_data.into()])
         .set_outputs(vec![output])
         .build();
     assert_ne!(txa.hash(), txb.hash());
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 f590f7ae81..52ce496367 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).pack())
+            .capacity(capacity_bytes!(80).into())
             .build();
 
         let tx2 = tx2_temp
diff --git a/test/src/specs/tx_pool/mod.rs b/test/src/specs/tx_pool/mod.rs
index 436fc44b93..b8e1abc45c 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, prelude::*, H256};
+use ckb_types::{bytes::Bytes, core::ScriptHashType, H256};
 
 fn type_lock_script_code_hash() -> H256 {
     build_genesis_type_id_script(OUTPUT_INDEX_SECP256K1_BLAKE160_SIGHASH_ALL)
         .calc_script_hash()
-        .unpack()
+        .into()
 }
 
 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 7e056380d5..cb6820d7ce 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).pack())
+        .capacity(capacity_bytes!(200).into())
         .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).pack())
+        .capacity(capacity_bytes!(80).into())
         .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).pack())
+            .capacity(capacity_bytes!(200).into())
             .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 280c506cc8..277e433f8e 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().unpack()))
+                    .any(|tx| tx.hash == tx1.hash().into()))
             })
             .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).pack())
+                .capacity(capacity_bytes!(99).into())
                 .build()])
             .build();
 
diff --git a/test/src/specs/tx_pool/replace.rs b/test/src/specs/tx_pool/replace.rs
index b6ef175906..bad81eb25f 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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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).pack())
+            .capacity(capacity_bytes!(99).into())
             .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).pack())
+            .capacity(capacity_bytes!(95).into())
             .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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx1.hash().into()]);
 
         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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx1.hash().into()]);
     }
 
     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).pack())
+            .capacity(capacity_bytes!(80).into())
             .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).pack())
+            .capacity(capacity_bytes!(90).into())
             .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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
     }
 
     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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
     }
 
     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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
     }
 
     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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![tx2.hash().into()]);
     }
 
     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).pack())
+            .capacity(capacity_bytes!(50).into())
             .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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().into()]);
 
         // let's try a new transaction with new higher fee
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(45).pack())
+            .capacity(capacity_bytes!(45).into())
             .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().unpack())
+            .map(|tx| tx.hash().into())
             .collect::<Vec<_>>();
-        expected.push(new_tx.hash().unpack());
+        expected.push(new_tx.hash().into());
         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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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).pack())
+            .capacity(capacity_bytes!(70).into())
             .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().unpack(),
-            txs[3].hash().unpack(),
-            txs[4].hash().unpack(),
+            txs[2].hash().into(),
+            txs[3].hash().into(),
+            txs[4].hash().into(),
         ];
         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.pack()).build();
+            let output = CellOutputBuilder::default().capacity(fee.into()).build();
 
             let tx2 = tx2_temp
                 .as_advanced_builder()
@@ -931,11 +931,8 @@ impl Spec for RbfConcurrency {
             assert_eq!(*s, Status::Rejected);
         }
 
-        let mut expected: Vec<ckb_types::H256> = conflicts
-            .iter()
-            .take(4)
-            .map(|x| x.hash().unpack())
-            .collect();
+        let mut expected: Vec<ckb_types::H256> =
+            conflicts.iter().take(4).map(|x| x.hash().into()).collect();
         expected.sort_unstable();
         assert_eq!(get_tx_pool_conflicts(node0), expected);
     }
@@ -991,7 +988,7 @@ impl Spec for RbfCellDepsCheck {
 
         // Create a new transaction for cell dep with high fee
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(80).pack())
+            .capacity(capacity_bytes!(80).into())
             .build();
         let new_tx = tx_a
             .as_advanced_builder()
@@ -1005,7 +1002,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().unpack()]);
+        assert_eq!(get_tx_pool_conflicts(node0), vec![new_tx.hash().into()]);
     }
 
     fn modify_app_config(&self, config: &mut ckb_app_config::CKBAppConfig) {
@@ -1163,7 +1160,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).pack())
+        .capacity(capacity_bytes!(90).into())
         .build();
 
     let tx1 = tx1.as_advanced_builder().set_outputs(vec![output]).build();
@@ -1189,7 +1186,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).pack())
+        .capacity(capacity_bytes!(95).into())
         .build();
 
     let tx2 = tx2_temp
@@ -1211,7 +1208,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().unpack()]);
+    assert_eq!(get_tx_pool_conflicts(node1), vec![tx2.hash().into()]);
 }
 
 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 76dab8dbe3..a28b8d8f26 100644
--- a/test/src/specs/tx_pool/send_defected_binary.rs
+++ b/test/src/specs/tx_pool/send_defected_binary.rs
@@ -58,7 +58,7 @@ impl Spec for SendDefectedBinary {
             .dep_type(DepType::DepGroup.into())
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(5000).pack())
+            .capacity(capacity_bytes!(5000).into())
             .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[..].pack())
+            .output_data(data[..].into())
             .build();
 
         let tx_hash = tx.hash();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+            .lock(Some(Bytes::from(vec![0u8; 65])).into())
             .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())).pack())
+            .lock(Some(Bytes::from(sig.serialize())).into())
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .inputs(inputs)
             .output(output)
-            .output_data(data[..].pack())
-            .witness(witness.as_bytes().pack())
+            .output_data(data[..].into())
+            .witness(witness.as_bytes().into())
             .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 ce4d4ec09e..70d2028c9a 100644
--- a/test/src/specs/tx_pool/send_large_cycles_tx.rs
+++ b/test/src/specs/tx_pool/send_large_cycles_tx.rs
@@ -325,8 +325,8 @@ 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.pack())
-        .code_hash(type_lock_script_code_hash().pack())
+        .args(lock_arg.into())
+        .code_hash(type_lock_script_code_hash().into())
         .hash_type(ScriptHashType::Type.into())
         .build();
     let cell_dep = CellDep::new_builder()
@@ -339,7 +339,7 @@ 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).pack())
+        .capacity(capacity_bytes!(100).into())
         .lock(lock)
         .build();
     let tx = TransactionBuilder::default()
@@ -348,9 +348,9 @@ fn build_tx(node: &Node, privkey: &Privkey, lock_arg: Bytes) -> TransactionView
         .output(output1)
         .output_data(Default::default())
         .build();
-    let tx_hash: H256 = tx.hash().unpack();
+    let tx_hash: H256 = tx.hash().into();
     let witness = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+        .lock(Some(Bytes::from(vec![0u8; 65])).into())
         .build();
     let witness_len = witness.as_slice().len() as u64;
     let message = {
@@ -365,9 +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())).pack())
+        .lock(Some(Bytes::from(sig.serialize())).into())
         .build();
     tx.as_advanced_builder()
-        .witness(witness.as_bytes().pack())
+        .witness(witness.as_bytes().into())
         .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 befbf60722..03341cade9 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.pack())
+            .capacity(capacity.into())
             .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().pack())
+            .capacity(capacity.safe_sub(1000u32).unwrap().into())
             .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 f0de38db6f..31c10a2e9f 100644
--- a/test/src/specs/tx_pool/send_multisig_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
@@ -53,7 +53,7 @@ impl Spec for SendMultiSigSecpTxUseDepGroup {
             .dep_type(DepType::DepGroup.into())
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(node.always_success_script())
             .build();
         let input = CellInput::new(OutPoint::new(cellbase_hash, 0), 0);
@@ -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)).pack())
+                .lock(Some(Bytes::from(lock)).into())
                 .build()
         };
         let witness_len = witness.as_slice().len() as u64;
@@ -90,14 +90,14 @@ impl Spec for SendMultiSigSecpTxUseDepGroup {
         });
         let witness = witness
             .as_builder()
-            .lock(Some(Bytes::from(lock)).pack())
+            .lock(Some(Bytes::from(lock)).into())
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .input(input)
             .output(output)
             .output_data(Default::default())
-            .witness(witness.as_bytes().pack())
+            .witness(witness.as_bytes().into())
             .build();
         info!("Send 1 multisig tx use dep group");
 
@@ -136,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()
-        .unpack()
+        .into()
 }
 
 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 7449c7454c..4e7c9b0c9e 100644
--- a/test/src/specs/tx_pool/send_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_secp_tx.rs
@@ -50,7 +50,7 @@ impl Spec for SendSecpTxUseDepGroup {
             .dep_type(DepType::DepGroup.into())
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(node.always_success_script())
             .build();
         let input = CellInput::new(OutPoint::new(cellbase_hash, 0), 0);
@@ -63,7 +63,7 @@ impl Spec for SendSecpTxUseDepGroup {
 
         let tx_hash = tx.hash();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+            .lock(Some(Bytes::from(vec![0u8; 65])).into())
             .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())).pack())
+            .lock(Some(Bytes::from(sig.serialize())).into())
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .input(input)
             .output(output)
             .output_data(Default::default())
-            .witness(witness.as_bytes().pack())
+            .witness(witness.as_bytes().into())
             .build();
         info!("Send 1 secp tx use dep group");
 
@@ -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.pack())
-            .code_hash(type_lock_script_code_hash().pack())
+            .args((&self.lock_arg).into())
+            .code_hash(type_lock_script_code_hash().into())
             .hash_type(ScriptHashType::Type.into())
             .build();
         let output1 = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(lock.clone())
             .build();
         let output2 = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100).into())
             .lock(lock)
             .build();
         let tx = TransactionBuilder::default()
@@ -176,9 +176,9 @@ impl Spec for CheckTypical2In2OutTx {
             .output_data(Default::default())
             .build();
 
-        let tx_hash: H256 = tx.hash().unpack();
+        let tx_hash: H256 = tx.hash().into();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+            .lock(Some(Bytes::from(vec![0u8; 65])).into())
             .build();
         let witness_len = witness.as_slice().len() as u64;
         let witness2 = Bytes::new();
@@ -197,20 +197,19 @@ impl Spec for CheckTypical2In2OutTx {
         let sig = self.privkey.sign_recoverable(&message).expect("sign");
         let witness = witness
             .as_builder()
-            .lock(Some(Bytes::from(sig.serialize())).pack())
+            .lock(Some(Bytes::from(sig.serialize())).into())
             .build();
         let tx = tx
             .as_advanced_builder()
-            .witness(witness.as_bytes().pack())
-            .witness(witness2.pack())
+            .witness(witness.as_bytes().into())
+            .witness(witness2.into())
             .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")
-            .pack();
+            .expect("should pass default outputs validator");
         node.mine(20);
 
         assert!(is_transaction_committed(node, &tx));
diff --git a/test/src/txo.rs b/test/src/txo.rs
index 7d9868b6f4..9d3697d98c 100644
--- a/test/src/txo.rs
+++ b/test/src/txo.rs
@@ -31,7 +31,7 @@ impl TXO {
     }
 
     pub fn capacity(&self) -> u64 {
-        self.output.capacity().unpack()
+        self.output.capacity().into()
     }
 
     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().pack())
+            .capacity(self.capacity().into())
             .build()
     }
 
@@ -161,12 +161,12 @@ impl TXOSet {
         self.iter()
             .map(|txo| {
                 let maximal_capacity = txo.capacity();
-                let minimal_capacity: u64 = txo.to_minimal_output().capacity().unpack();
+                let minimal_capacity: u64 = txo.to_minimal_output().capacity().into();
                 let actual_capacity = rng.gen_range(minimal_capacity..=maximal_capacity);
                 let output = txo
                     .to_equivalent_output()
                     .as_builder()
-                    .capacity(actual_capacity.pack())
+                    .capacity(actual_capacity.into())
                     .build();
                 TransactionBuilder::default()
                     .cell_deps(cell_deps.clone())
@@ -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().unpack();
+        let minimal_capacity: u64 = minimal.capacity().into();
         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.pack()).build());
+                outputs.push(minimal.as_builder().capacity(input_capacity.into()).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.pack())
+                    .index(i.into())
                     .build();
                 TXO::new(out_point, output)
             });
diff --git a/test/src/util/cell.rs b/test/src/util/cell.rs
index 78a2303235..70608c1123 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().pack())
+        .capacity(cell.capacity().into())
         .build()
 }
diff --git a/test/src/util/mining.rs b/test/src/util/mining.rs
index ebbf686522..17bd1ff87c 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.unpack())
+                .any(|tx| tx.hash == tx_hash.into())
         });
     }
 
diff --git a/test/src/util/transaction.rs b/test/src/util/transaction.rs
index 35e640cd64..bf5f7637eb 100644
--- a/test/src/util/transaction.rs
+++ b/test/src/util/transaction.rs
@@ -39,7 +39,7 @@ pub fn always_success_transactions_with_rand_data(
                     (0..1600)
                         .map(|_| rand::random::<u8>())
                         .collect::<Vec<_>>()
-                        .pack()
+                        .into()
                 })
                 .collect::<Vec<packed::Bytes>>(),
         )
@@ -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()].pack())
+                .tx_hashes(vec![tx.hash()].into())
                 .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.pack())
+        .cycles(cycles.into())
         .transaction(tx.data())
         .build();
 
diff --git a/test/src/utils.rs b/test/src/utils.rs
index 57d9227ac9..263ca9291e 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::{
-        BlockFilterMessage, BlockTransactions, Byte32, CompactBlock, GetBlocks, RelayMessage,
+        self, BlockFilterMessage, BlockTransactions, Byte32, CompactBlock, GetBlocks, RelayMessage,
         RelayTransaction, RelayTransactionHashes, RelayTransactions, SendBlock, SendHeaders,
         SyncMessage,
     },
@@ -55,7 +55,8 @@ pub fn build_block_transactions(block: &BlockView) -> Bytes {
                 .into_iter()
                 .map(|view| view.data())
                 .skip(1)
-                .pack(),
+                .collect::<Vec<packed::Transaction>>()
+                .into(),
         )
         .build();
 
@@ -76,7 +77,7 @@ pub fn build_headers(headers: &[HeaderView]) -> Bytes {
                 .iter()
                 .map(|view| view.data())
                 .collect::<Vec<_>>()
-                .pack(),
+                .into(),
         )
         .build();
 
@@ -95,7 +96,13 @@ 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).pack())
+        .block_hashes(
+            hashes
+                .iter()
+                .map(ToOwned::to_owned)
+                .collect::<Vec<packed::Byte32>>()
+                .into(),
+        )
         .build();
 
     SyncMessage::new_builder()
@@ -105,14 +112,17 @@ 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.pack())
-            .transaction(tx.data())
-            .build()
-    });
+    let transactions = transactions
+        .iter()
+        .map(|(tx, cycles)| {
+            RelayTransaction::new_builder()
+                .cycles(cycles.into())
+                .transaction(tx.data())
+                .build()
+        })
+        .collect::<Vec<packed::RelayTransaction>>();
     let txs = RelayTransactions::new_builder()
-        .transactions(transactions.pack())
+        .transactions(transactions.into())
         .build();
 
     RelayMessage::new_builder().set(txs).build().as_bytes()
@@ -120,7 +130,13 @@ 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).pack())
+        .tx_hashes(
+            hashes
+                .iter()
+                .map(ToOwned::to_owned)
+                .collect::<Vec<Byte32>>()
+                .into(),
+        )
         .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 81acca0951..661f084b75 100644
--- a/tx-pool/src/block_assembler/mod.rs
+++ b/tx-pool/src/block_assembler/mod.rs
@@ -459,8 +459,8 @@ impl BlockAssembler {
     ) -> CellbaseWitness {
         let hash_type: ScriptHashType = config.hash_type.clone().into();
         let cellbase_lock = Script::new_builder()
-            .args(config.args.as_bytes().pack())
-            .code_hash(config.code_hash.pack())
+            .args(config.args.as_bytes().into())
+            .code_hash((&config.code_hash).into())
             .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.pack())
+            .message(message.into())
             .build()
     }
 
@@ -502,11 +502,11 @@ impl BlockAssembler {
             })?;
             let input = CellInput::new_cellbase_input(candidate_number);
             let output = CellOutput::new_builder()
-                .capacity(block_reward.total.pack())
+                .capacity(block_reward.total.into())
                 .lock(target_lock)
                 .build();
 
-            let witness = cellbase_witness.as_bytes().pack();
+            let witness = cellbase_witness.as_bytes().into();
             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().pack();
+            let bytes = chain_root.calc_mmr_hash().as_bytes().into();
             Ok(Some(bytes))
         } else {
             Ok(None)
@@ -564,18 +564,30 @@ impl BlockAssembler {
         let block = if let Some(extension) = extension_opt {
             packed::BlockV1::new_builder()
                 .header(header)
-                .transactions(vec![cellbase].pack())
-                .uncles(uncles.iter().map(|u| u.data()).pack())
-                .proposals(proposals.cloned().collect::<Vec<_>>().pack())
+                .transactions(vec![cellbase].into())
+                .uncles(
+                    uncles
+                        .iter()
+                        .map(|u| u.data())
+                        .collect::<Vec<packed::UncleBlock>>()
+                        .into(),
+                )
+                .proposals(proposals.cloned().collect::<Vec<_>>().into())
                 .extension(extension)
                 .build()
                 .as_v0()
         } else {
             packed::Block::new_builder()
                 .header(header)
-                .transactions(vec![cellbase].pack())
-                .uncles(uncles.iter().map(|u| u.data()).pack())
-                .proposals(proposals.cloned().collect::<Vec<_>>().pack())
+                .transactions(vec![cellbase].into())
+                .uncles(
+                    uncles
+                        .iter()
+                        .map(|u| u.data())
+                        .collect::<Vec<packed::UncleBlock>>()
+                        .into(),
+                )
+                .proposals(proposals.cloned().collect::<Vec<_>>().into())
                 .build()
         };
         block.serialized_size_without_uncle_proposals()
@@ -728,7 +740,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.unpack(),
+            parent_hash: (&template.parent_hash).into(),
             cycles_limit: template.cycles_limit.into(),
             bytes_limit: template.bytes_limit.into(),
             uncles_count_limit: u64::from(template.uncles_count_limit).into(),
@@ -918,7 +930,7 @@ impl BlockTemplateBuilder {
 
 pub(crate) fn uncle_to_template(uncle: &UncleBlockView) -> UncleTemplate {
     UncleTemplate {
-        hash: uncle.hash().unpack(),
+        hash: uncle.hash().into(),
         required: false,
         proposals: uncle
             .data()
@@ -932,7 +944,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().unpack(),
+        hash: entry.transaction().hash().into(),
         required: false, // unimplemented
         cycles: Some(entry.cycles.into()),
         depends: None, // unimplemented
@@ -942,7 +954,7 @@ pub(crate) fn tx_entry_to_template(entry: &TxEntry) -> TransactionTemplate {
 
 pub(crate) fn cellbase_to_template(tx: &TransactionView) -> CellbaseTemplate {
     CellbaseTemplate {
-        hash: tx.hash().unpack(),
+        hash: tx.hash().into(),
         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 6d39933ecb..8c66d154ca 100644
--- a/tx-pool/src/block_assembler/tests.rs
+++ b/tx-pool/src/block_assembler/tests.rs
@@ -1,7 +1,4 @@
-use ckb_types::{
-    core::{BlockBuilder, BlockNumber, EpochNumberWithFraction},
-    prelude::*,
-};
+use ckb_types::core::{BlockBuilder, BlockNumber, EpochNumberWithFraction};
 
 use crate::block_assembler::candidate_uncles::{
     CandidateUncles, MAX_CANDIDATE_UNCLES, MAX_PER_HEIGHT,
@@ -30,8 +27,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.pack())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 10000).pack())
+            .number(number.into())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 10000).into())
             .build()
             .as_uncle();
         blocks.push(block);
@@ -60,7 +57,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).pack())
+            .timestamp((i as u64).into())
             .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 575452785c..b62f55d4c6 100644
--- a/tx-pool/src/component/pool_map.rs
+++ b/tx-pool/src/component/pool_map.rs
@@ -11,7 +11,6 @@ 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,
@@ -186,7 +185,7 @@ impl PoolMap {
             .and_then(|entry| {
                 entry
                     .transaction()
-                    .output_with_data(out_point.index().unpack())
+                    .output_with_data(out_point.index().into())
             })
     }
 
diff --git a/tx-pool/src/component/tests/pending.rs b/tx-pool/src/component/tests/pending.rs
index e262248354..bcef42ef01 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, prelude::*};
+use ckb_types::{h256, packed::Byte32};
 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").pack(), 1), (&h256!("0x3").pack(), 2)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 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").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").pack(), 1)],
-        vec![(&h256!("0x5").pack(), 1)],
+        vec![(&h256!("0x4").into(), 1)],
+        vec![(&h256!("0x5").into(), 1)],
         3,
     );
     let tx4 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x1").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x1").into(), 1)],
         3,
     );
-    let tx5 = build_tx(vec![(&h256!("0x5").pack(), 1)], 3);
+    let tx5 = build_tx(vec![(&h256!("0x5").into(), 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").pack();
+    let header: Byte32 = h256!("0x1").into();
     let tx = build_tx_with_header_dep(
-        vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)],
+        vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 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").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 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 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").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").pack(), 1)],
-        vec![(&h256!("0x5").pack(), 1)],
+        vec![(&h256!("0x4").into(), 1)],
+        vec![(&h256!("0x5").into(), 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").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").pack(), 1)],
-        vec![(&h256!("0x5").pack(), 1)],
+        vec![(&h256!("0x4").into(), 1)],
+        vec![(&h256!("0x5").into(), 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").pack(), 1)], 1);
-    let tx2 = build_tx(vec![(&h256!("0x1").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
+    let tx2 = build_tx(vec![(&h256!("0x1").into(), 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").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").pack(), 1)],
-        vec![(&h256!("0x5").pack(), 1)],
+        vec![(&h256!("0x4").into(), 1)],
+        vec![(&h256!("0x5").into(), 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").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").pack(), 1)],
-        vec![(&h256!("0x5").pack(), 1)],
+        vec![(&h256!("0x4").into(), 1)],
+        vec![(&h256!("0x5").into(), 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").pack(), 1)], 1);
+    let tx1 = build_tx(vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 1)], 1);
     let tx2 = build_tx(
-        vec![(&h256!("0x2").pack(), 1), (&h256!("0x3").pack(), 1)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 1)],
         3,
     );
     let tx3 = build_tx_with_dep(
-        vec![(&h256!("0x4").pack(), 1)],
-        vec![(&h256!("0x5").pack(), 1)],
+        vec![(&h256!("0x4").into(), 1)],
+        vec![(&h256!("0x5").into(), 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").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 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 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 236d4b10a9..86f24b9704 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::{CellOutputBuilder, ScriptBuilder};
+use ckb_types::packed::{self, 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").pack(), 1), (&h256!("0x3").pack(), 2)],
+        vec![(&h256!("0x2").into(), 1), (&h256!("0x3").into(), 2)],
         3,
     );
 
@@ -517,19 +517,19 @@ fn test_get_ancestors() {
 
 #[test]
 fn test_dep_group() {
-    let tx1 = build_tx(vec![(&h256!("0x1").pack(), 0)], 1);
+    let tx1 = build_tx(vec![(&h256!("0x1").into(), 0)], 1);
     let tx1_out_point = OutPoint::new(tx1.hash(), 0);
 
     // Dep group cell
-    let tx2_data = vec![tx1_out_point.clone()].pack().as_bytes();
+    let tx2_data = Into::<packed::OutPointVec>::into(vec![tx1_out_point.clone()]).as_bytes();
     let tx2 = TransactionBuilder::default()
-        .input(CellInput::new(OutPoint::new(h256!("0x2").pack(), 0), 0))
+        .input(CellInput::new(OutPoint::new(h256!("0x2").into(), 0), 0))
         .output(
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(1000).unwrap().pack())
+                .capacity(Capacity::bytes(1000).unwrap().into())
                 .build(),
         )
-        .output_data(tx2_data.pack())
+        .output_data((&tx2_data).into())
         .build();
     let tx2_out_point = OutPoint::new(tx2.hash(), 0);
 
@@ -540,13 +540,13 @@ fn test_dep_group() {
         .build();
     let tx3 = TransactionBuilder::default()
         .cell_dep(dep)
-        .input(CellInput::new(OutPoint::new(h256!("0x3").pack(), 0), 0))
+        .input(CellInput::new(OutPoint::new(h256!("0x3").into(), 0), 0))
         .output(
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(3).unwrap().pack())
+                .capacity(Capacity::bytes(3).unwrap().into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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").pack();
+    let header: Byte32 = h256!("0x1").into();
     let tx = build_tx_with_header_dep(
-        vec![(&Byte32::zero(), 1), (&h256!("0x1").pack(), 1)],
+        vec![(&Byte32::zero(), 1), (&h256!("0x1").into(), 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").pack(), 0)],
+        vec![(&h256!("0x1").into(), 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").pack(), 0)], 1);
+    let tx2 = build_tx_with_dep(vec![(&tx1_hash, 0)], vec![(&h256!("0x2").into(), 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").pack(), 0)));
+        .contains_key(&OutPoint::new(h256!("0x1").into(), 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.pack())
+                                .index(0u32.into())
                                 .build(),
                         )
                         .build(),
                 )
-                .witness(Bytes::new().pack())
+                .witness(Bytes::new().into())
                 .build(),
             rng.gen_range(0..1000),
             Capacity::shannons(200),
@@ -748,23 +748,23 @@ 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()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let tx = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1)
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
diff --git a/tx-pool/src/component/tests/score_key.rs b/tx-pool/src/component/tests/score_key.rs
index c12cc7426c..2a3660be7b 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.pack())
+                            .index(0u32.into())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().pack())
+            .witness(Bytes::new().into())
             .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.pack())
+                            .index(0u32.into())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().pack())
+            .witness(Bytes::new().into())
             .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.pack())
+                            .index(0u32.into())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().pack())
+            .witness(Bytes::new().into())
             .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.pack())
+                            .index(0u32.into())
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().pack())
+            .witness(Bytes::new().into())
             .build(),
         200,
         Capacity::shannons(200),
diff --git a/tx-pool/src/component/tests/util.rs b/tx-pool/src/component/tests/util.rs
index 32d4563d61..aa04530696 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().pack())
+                .capacity(Capacity::bytes(i + 1).unwrap().into())
                 .build()
         }))
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
         .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().pack())
+                .capacity(Capacity::bytes(i + 1).unwrap().into())
                 .build()
         }))
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
         .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().pack())
+                .capacity(Capacity::bytes(i + 1).unwrap().into())
                 .build()
         }))
-        .outputs_data((0..outputs_len).map(|_| Bytes::new().pack()))
+        .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
         .build()
 }
diff --git a/util/dao/src/lib.rs b/util/dao/src/lib.rs
index ebb550871c..eb56e7df3e 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().unpack();
+                    let output_capacity: Capacity = cell_meta.cell_output.capacity().into();
                     tx_capacities.safe_add(output_capacity)
                 },
             )?;
@@ -248,14 +248,11 @@ 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(&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());
+                                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());
                                 if header_deps_index_data.is_none()
                                     || header_deps_index_data.clone().map(|data| data.len())
                                         != Some(8)
@@ -278,7 +275,7 @@ impl<'a, DL: CellDataProvider + EpochProvider + HeaderProvider> DaoCalculator<'a
                             withdrawing_header_hash,
                         )
                     } else {
-                        Ok(output.capacity().unpack())
+                        Ok(output.capacity().into())
                     }
                 };
                 capacity.and_then(|c| c.safe_add(capacities).map_err(Into::into))
@@ -310,7 +307,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().unpack();
+        let output_capacity: Capacity = output.capacity().into();
         let counted_capacity = output_capacity.safe_sub(occupied_capacity)?;
         let withdraw_counted_capacity = u128::from(counted_capacity.as_u64())
             * u128::from(withdrawing_ar)
@@ -333,7 +330,7 @@ pub fn modified_occupied_capacity(
             && tx_info.is_cellbase()
             && cell_meta.cell_output.lock().args().raw_data() == consensus.satoshi_pubkey_hash.0[..]
         {
-            return Unpack::<Capacity>::unpack(&cell_meta.cell_output.capacity())
+            return Into::<Capacity>::into(&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 bbb4c2cf36..586d8b50ba 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").pack())
+        .last_block_hash_in_previous_epoch(h256!("0x1").into())
         .start_number(epoch_start.unwrap_or_else(|| parent.number() - 1000))
         .length(2091)
         .compact_target(DIFF_TWO)
         .build();
-    let epoch_hash = h256!("0x123455").pack();
+    let epoch_hash = h256!("0x123455").into();
 
     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.pack())
-        .epoch(epoch.pack())
+        .number(parent_number.into())
+        .epoch(epoch.into())
         .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.pack())
+        .number(parent_number.into())
         .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.pack())
-        .epoch(epoch.pack())
+        .number(parent_number.into())
+        .epoch(epoch.into())
         .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.pack())
-        .epoch(epoch.pack())
+        .number(parent_number.into())
+        .epoch(epoch.into())
         .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.pack())
-        .epoch(epoch.pack())
+        .number(parent_number.into())
+        .epoch(epoch.into())
         .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).pack())
+        .capacity(capacity_bytes!(10000).into())
         .build();
     let output_cell_data = Bytes::from("abcde12345");
     let output_cell = CellOutput::new_builder()
-        .capacity(capacity_bytes!(20000).pack())
+        .capacity(capacity_bytes!(20000).into())
         .build();
 
     let tx = TransactionBuilder::default()
         .output(output_cell)
-        .output_data(output_cell_data.pack())
+        .output_data(output_cell_data.into())
         .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).pack())
+        .capacity(capacity_bytes!(1000000).into())
         .build();
     let tx = TransactionBuilder::default()
         .output(output.clone())
-        .output_data(data.pack())
+        .output_data((&data).into())
         .build();
     let epoch = EpochNumberWithFraction::new(1, 100, 1000);
     let deposit_header = HeaderBuilder::default()
-        .number(100.pack())
-        .epoch(epoch.pack())
+        .number(100.into())
+        .epoch(epoch.into())
         .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.pack())
-        .epoch(epoch.pack())
+        .number(200.into())
+        .epoch(epoch.into())
         .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).pack())
+        .capacity(Capacity::shannons(18_446_744_073_709_550_000).into())
         .build();
     let tx = TransactionBuilder::default().output(output.clone()).build();
     let epoch = EpochNumberWithFraction::new(1, 100, 1000);
     let deposit_header = HeaderBuilder::default()
-        .number(100.pack())
-        .epoch(epoch.pack())
+        .number(100.into())
+        .epoch(epoch.into())
         .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.pack())
-        .epoch(epoch.pack())
+        .number(200.into())
+        .epoch(epoch.into())
         .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 3e67098a43..ef2da02c14 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().unpack();
+                let cap: Capacity = output.capacity().into();
                 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[..]
                 {
-                    Unpack::<Capacity>::unpack(&output.capacity())
+                    Into::<Capacity>::into(&output.capacity())
                         .safe_mul_ratio(satoshi_cell_occupied_ratio)
                 } else {
                     Capacity::bytes(data.len()).and_then(|c| output.occupied_capacity(c))
@@ -128,7 +128,6 @@ 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)]
@@ -160,7 +159,7 @@ mod tests {
             ),
         ];
         for (dao_h256, ar, c, s, u) in cases {
-            let dao_byte32: Byte32 = dao_h256.pack();
+            let dao_byte32: Byte32 = dao_h256.into();
             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 01ee940cc5..664298d50c 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_value();
+pub(crate) const DICT_HEX_ERROR: u8 = u8::MAX;
 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 3a73bd2084..e400ed16d7 100644
--- a/util/gen-types/src/conversion/blockchain/mod.rs
+++ b/util/gen-types/src/conversion/blockchain/mod.rs
@@ -24,10 +24,10 @@ impl<'r> Unpack<[u8; 32]> for packed::Byte32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!([u8; 32], Byte32);
 
-impl<'r> Into<[u8; 32]> for packed::Byte32Reader<'r> {
-    fn into(self) -> [u8; 32] {
+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(self.raw_data());
+        b.copy_from_slice(value.raw_data());
         b
     }
 }
@@ -48,10 +48,10 @@ impl<'r> Unpack<[u8; 10]> for packed::ProposalShortIdReader<'r> {
 }
 impl_conversion_for_entity_unpack!([u8; 10], ProposalShortId);
 
-impl<'r> Into<[u8; 10]> for packed::ProposalShortIdReader<'r> {
-    fn into(self) -> [u8; 10] {
+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(self.raw_data());
+        b.copy_from_slice(value.raw_data());
         b
     }
 }
@@ -88,9 +88,9 @@ impl<'r> Unpack<Bytes> for packed::BytesReader<'r> {
     }
 }
 
-impl<'r> Into<Bytes> for packed::BytesReader<'r> {
-    fn into(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())
     }
 }
 
@@ -100,9 +100,9 @@ impl Unpack<Bytes> for packed::Bytes {
     }
 }
 
-impl Into<Bytes> for packed::Bytes {
-    fn into(self) -> Bytes {
-        self.raw_data()
+impl From<packed::Bytes> for Bytes {
+    fn from(value: packed::Bytes) -> Bytes {
+        value.raw_data()
     }
 }
 
diff --git a/util/gen-types/src/conversion/blockchain/std_env.rs b/util/gen-types/src/conversion/blockchain/std_env.rs
index 93343709b3..696fe77123 100644
--- a/util/gen-types/src/conversion/blockchain/std_env.rs
+++ b/util/gen-types/src/conversion/blockchain/std_env.rs
@@ -29,9 +29,9 @@ impl<'r> Unpack<Capacity> for packed::Uint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(Capacity, Uint64);
 
-impl<'r> Into<Capacity> for packed::Uint64Reader<'r> {
-    fn into(self) -> Capacity {
-        Capacity::shannons(self.into())
+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);
@@ -62,9 +62,9 @@ impl<'r> Unpack<U256> for packed::Uint256Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(U256, Uint256);
 
-impl<'r> Into<U256> for packed::Uint256Reader<'r> {
-    fn into(self) -> U256 {
-        U256::from_little_endian(self.as_slice()).expect("internal error: fail to unpack U256")
+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);
@@ -94,9 +94,9 @@ impl<'r> Unpack<H256> for packed::Byte32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(H256, Byte32);
 
-impl<'r> Into<H256> for packed::Byte32Reader<'r> {
-    fn into(self) -> H256 {
-        H256::from_slice(self.as_slice()).expect("internal error: fail to unpack H256")
+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);
diff --git a/util/gen-types/src/conversion/primitive.rs b/util/gen-types/src/conversion/primitive.rs
index 80ef6b55de..b0a326abe8 100644
--- a/util/gen-types/src/conversion/primitive.rs
+++ b/util/gen-types/src/conversion/primitive.rs
@@ -26,9 +26,9 @@ impl From<&bool> for packed::Bool {
     }
 }
 
-impl<'r> Into<bool> for packed::BoolReader<'r> {
-    fn into(self) -> bool {
-        match self.as_slice()[0] {
+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!(),
@@ -119,10 +119,10 @@ impl From<&usize> for packed::Uint32 {
     }
 }
 
-impl<'r> Into<u32> for packed::Uint32Reader<'r> {
-    fn into(self) -> u32 {
+impl<'r> From<packed::Uint32Reader<'r>> for u32 {
+    fn from(value: packed::Uint32Reader<'r>) -> u32 {
         let mut b = [0u8; 4];
-        b.copy_from_slice(self.as_slice());
+        b.copy_from_slice(value.as_slice());
         u32::from_le_bytes(b)
     }
 }
@@ -136,10 +136,10 @@ impl<'r> Unpack<u32> for packed::Uint32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u32, Uint32);
 
-impl<'r> Into<u64> for packed::Uint64Reader<'r> {
-    fn into(self) -> u64 {
+impl<'r> From<packed::Uint64Reader<'r>> for u64 {
+    fn from(value: packed::Uint64Reader<'r>) -> u64 {
         let mut b = [0u8; 8];
-        b.copy_from_slice(self.as_slice());
+        b.copy_from_slice(value.as_slice());
         u64::from_le_bytes(b)
     }
 }
@@ -153,10 +153,10 @@ impl<'r> Unpack<u64> for packed::Uint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u64, Uint64);
 
-impl<'r> Into<u128> for packed::Uint128Reader<'r> {
-    fn into(self) -> u128 {
+impl<'r> From<packed::Uint128Reader<'r>> for u128 {
+    fn from(value: packed::Uint128Reader<'r>) -> u128 {
         let mut b = [0u8; 16];
-        b.copy_from_slice(self.as_slice());
+        b.copy_from_slice(value.as_slice());
         u128::from_le_bytes(b)
     }
 }
@@ -170,9 +170,9 @@ impl<'r> Unpack<u128> for packed::Uint128Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u128, Uint128);
 
-impl<'r> Into<usize> for packed::Uint32Reader<'r> {
-    fn into(self) -> usize {
-        let x: u32 = self.into();
+impl<'r> From<packed::Uint32Reader<'r>> for usize {
+    fn from(value: packed::Uint32Reader<'r>) -> usize {
+        let x: u32 = value.into();
         x as usize
     }
 }
@@ -239,10 +239,10 @@ impl From<&usize> for packed::BeUint32 {
     }
 }
 
-impl<'r> Into<u32> for packed::BeUint32Reader<'r> {
-    fn into(self) -> u32 {
+impl<'r> From<packed::BeUint32Reader<'r>> for u32 {
+    fn from(value: packed::BeUint32Reader<'r>) -> u32 {
         let mut b = [0u8; 4];
-        b.copy_from_slice(self.as_slice());
+        b.copy_from_slice(value.as_slice());
         u32::from_be_bytes(b)
     }
 }
@@ -256,10 +256,10 @@ impl<'r> Unpack<u32> for packed::BeUint32Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u32, BeUint32);
 
-impl<'r> Into<u64> for packed::BeUint64Reader<'r> {
-    fn into(self) -> u64 {
+impl<'r> From<packed::BeUint64Reader<'r>> for u64 {
+    fn from(value: packed::BeUint64Reader<'r>) -> u64 {
         let mut b = [0u8; 8];
-        b.copy_from_slice(self.as_slice());
+        b.copy_from_slice(value.as_slice());
         u64::from_be_bytes(b)
     }
 }
@@ -273,9 +273,9 @@ impl<'r> Unpack<u64> for packed::BeUint64Reader<'r> {
 }
 impl_conversion_for_entity_unpack!(u64, BeUint64);
 
-impl<'r> Into<usize> for packed::BeUint32Reader<'r> {
-    fn into(self) -> usize {
-        let x: u32 = self.into();
+impl<'r> From<packed::BeUint32Reader<'r>> for usize {
+    fn from(value: packed::BeUint32Reader<'r>) -> usize {
+        let x: u32 = value.into();
         x as usize
     }
 }
@@ -320,9 +320,9 @@ impl<const N: usize> From<&[u8; N]> for packed::Bytes {
     }
 }
 
-impl<'r> Into<Vec<u8>> for packed::BytesReader<'r> {
-    fn into(self) -> Vec<u8> {
-        self.raw_data().to_owned()
+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);
@@ -386,9 +386,9 @@ impl<'r> Unpack<Option<Vec<u64>>> for packed::Uint64VecOptReader<'r> {
     }
 }
 
-impl<'r> Into<Option<Vec<u64>>> for packed::Uint64VecOptReader<'r> {
-    fn into(self) -> Option<Vec<u64>> {
-        self.to_opt().map(|x| x.into())
+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())
     }
 }
 
diff --git a/util/gen-types/src/conversion/utilities.rs b/util/gen-types/src/conversion/utilities.rs
index 7ddb20265b..2109c79bff 100644
--- a/util/gen-types/src/conversion/utilities.rs
+++ b/util/gen-types/src/conversion/utilities.rs
@@ -65,11 +65,11 @@ macro_rules! impl_conversion_for_option_unpack {
     };
 }
 
-macro_rules! impl_conversion_for_option_into {
+macro_rules! impl_conversion_for_option_reader_from {
     ($original:ty, $entity:ident, $reader:ident) => {
-        impl<'r> Into<Option<$original>> for packed::$reader<'r> {
-            fn into(self) -> Option<$original> {
-                self.to_opt().map(|x| x.into())
+        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);
@@ -86,7 +86,7 @@ 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_into!($original, $entity, $reader);
+        impl_conversion_for_option_reader_from!($original, $entity, $reader);
     };
 }
 
@@ -137,11 +137,11 @@ macro_rules! impl_conversion_for_vector_unpack {
     };
 }
 
-macro_rules! impl_conversion_for_vector_into {
+macro_rules! impl_conversion_for_vector_reader_from {
     ($original:ty, $entity:ident, $reader:ident) => {
-        impl<'r> Into<Vec<$original>> for packed::$reader<'r> {
-            fn into(self) -> Vec<$original> {
-                self.iter().map(|x| x.into()).collect()
+        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);
@@ -158,7 +158,7 @@ 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_into!($original, $entity, $reader);
+        impl_conversion_for_vector_reader_from!($original, $entity, $reader);
     };
 }
 
diff --git a/util/gen-types/src/generated/mod.rs b/util/gen-types/src/generated/mod.rs
index fd81a946d0..03d3f97092 100644
--- a/util/gen-types/src/generated/mod.rs
+++ b/util/gen-types/src/generated/mod.rs
@@ -3,6 +3,8 @@
 #![doc(hidden)]
 #![allow(warnings)]
 #![allow(missing_docs)]
+#![allow(clippy::all)]
+#![allow(clippy::fallible_impl_from)]
 
 #[allow(clippy::all)]
 mod blockchain;
diff --git a/util/indexer-sync/src/lib.rs b/util/indexer-sync/src/lib.rs
index 135d516e17..4c8325be7e 100644
--- a/util/indexer-sync/src/lib.rs
+++ b/util/indexer-sync/src/lib.rs
@@ -26,7 +26,6 @@ use ckb_store::ChainStore;
 use ckb_types::{
     core::{self, BlockNumber, BlockView},
     packed::Byte32,
-    prelude::*,
     H256,
 };
 use rocksdb::prelude::*;
@@ -112,7 +111,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.pack()) {
+                if let Some(init_tip) = self.secondary_db.get_block_header(&init_tip_hash.into()) {
                     if indexer_tip >= init_tip.number() {
                         return;
                     }
@@ -127,7 +126,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.pack()) {
+                if let Some(header) = self.secondary_db.get_block_header(&init_tip_hash.into()) {
                     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 33f0813e86..6b87fd4378 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().unpack())
+                                        .get(out_point.index().into())
                                         .expect("index should match"),
                                     &tx.outputs_data()
-                                        .get(out_point.index().unpack())
+                                        .get(out_point.index().into())
                                         .expect("index should match"),
                                 )
                                 .into()
@@ -380,7 +380,7 @@ where
                                 &output.lock(),
                                 generated_by_block_number,
                                 generated_by_tx_index,
-                                out_point.index().unpack(),
+                                out_point.index().into(),
                             )
                             .into_vec(),
                         )?;
@@ -400,7 +400,7 @@ where
                                     &script,
                                     generated_by_block_number,
                                     generated_by_tx_index,
-                                    out_point.index().unpack(),
+                                    out_point.index().into(),
                                 )
                                 .into_vec(),
                             )?;
@@ -629,7 +629,7 @@ where
                                     &output.lock(),
                                     generated_by_block_number,
                                     generated_by_tx_index,
-                                    out_point.index().unpack(),
+                                    out_point.index().into(),
                                 ),
                                 Value::TxHash(&out_point.tx_hash()),
                             )?;
@@ -649,7 +649,7 @@ where
                                         &script,
                                         generated_by_block_number,
                                         generated_by_tx_index,
-                                        out_point.index().unpack(),
+                                        out_point.index().into(),
                                     ),
                                     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.pack(), true),
+                Key::Header(init_tip_number, &init_tip_hash.into(), true),
                 vec![],
             )
             .expect("insert init tip header should be OK");
@@ -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()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -983,7 +983,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -993,9 +993,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1)
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1004,9 +1004,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2)
-                    .type_(Some(type_script2).pack())
+                    .type_(Some(type_script2).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1016,7 +1016,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).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()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1066,7 +1066,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1076,9 +1076,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1087,9 +1087,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1099,7 +1099,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1108,7 +1108,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1119,9 +1119,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1131,9 +1131,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2)
-                    .type_(Some(type_script2).pack())
+                    .type_(Some(type_script2).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1145,11 +1145,11 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1.pack())
+                    .number(1.into())
                     .parent_hash(block0.hash())
                     .epoch(
                         EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .pack(),
+                            .into(),
                     )
                     .build(),
             )
@@ -1199,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()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1227,7 +1227,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1237,9 +1237,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1248,9 +1248,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1260,7 +1260,7 @@ mod tests {
             .transaction(cellbase0.clone())
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1269,7 +1269,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1280,9 +1280,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1292,9 +1292,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1304,9 +1304,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx11.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2).pack())
+                    .type_(Some(type_script2).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1319,11 +1319,11 @@ mod tests {
             .transaction(tx12)
             .header(
                 HeaderBuilder::default()
-                    .number(1.pack())
+                    .number(1.into())
                     .parent_hash(block0.hash())
                     .epoch(
                         EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .pack(),
+                            .into(),
                     )
                     .build(),
             )
@@ -1371,27 +1371,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1399,7 +1399,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1409,9 +1409,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1420,9 +1420,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1432,7 +1432,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1445,7 +1445,7 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
                         .build(),
                 )
@@ -1456,9 +1456,9 @@ mod tests {
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()).pack())
+                        .type_(Some(type_script1.clone()).into())
                         .build(),
                 )
                 .output_data(Default::default())
@@ -1468,9 +1468,9 @@ mod tests {
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000).pack())
+                        .capacity(capacity_bytes!(2000).into())
                         .lock(lock_script2.clone())
-                        .type_(Some(type_script2.clone()).pack())
+                        .type_(Some(type_script2.clone()).into())
                         .build(),
                 )
                 .output_data(Default::default())
@@ -1482,7 +1482,7 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).pack())
+                        .number((pre_block.number() + 1).into())
                         .parent_hash(pre_block.hash())
                         .epoch(
                             EpochNumberWithFraction::new(
@@ -1490,7 +1490,7 @@ mod tests {
                                 pre_block.number(),
                                 1000,
                             )
-                            .pack(),
+                            .into(),
                         )
                         .build(),
                 )
@@ -1526,9 +1526,9 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1536,7 +1536,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1545,7 +1545,7 @@ mod tests {
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1558,7 +1558,7 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
                         .build(),
                 )
@@ -1569,7 +1569,7 @@ mod tests {
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).pack())
+                        .number((pre_block.number() + 1).into())
                         .parent_hash(pre_block.hash())
                         .epoch(
                             EpochNumberWithFraction::new(
@@ -1577,7 +1577,7 @@ mod tests {
                                 pre_block.number(),
                                 1000,
                             )
-                            .pack(),
+                            .into(),
                         )
                         .build(),
                 )
@@ -1598,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()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1626,7 +1626,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1636,9 +1636,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1)
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1647,9 +1647,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2)
-                    .type_(Some(type_script2).pack())
+                    .type_(Some(type_script2).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1659,7 +1659,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1682,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]).pack())
+            .code_hash(H256([0; 32]).into())
             .hash_type(ScriptHashType::Data.into())
             .build();
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1697,7 +1697,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(all_zero_lock_script.clone())
                     .build(),
             )
@@ -1706,7 +1706,7 @@ mod tests {
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1728,7 +1728,7 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
                         .build(),
                 )
@@ -1739,7 +1739,7 @@ mod tests {
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).pack())
+                        .number((pre_block.number() + 1).into())
                         .parent_hash(pre_block.hash())
                         .epoch(
                             EpochNumberWithFraction::new(
@@ -1747,7 +1747,7 @@ mod tests {
                                 pre_block.number(),
                                 1000,
                             )
-                            .pack(),
+                            .into(),
                         )
                         .build(),
                 )
@@ -1778,8 +1778,8 @@ mod tests {
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number(i.pack())
-                        .epoch(EpochNumberWithFraction::new(i + 1, i, 1000).pack())
+                        .number(i.into())
+                        .epoch(EpochNumberWithFraction::new(i + 1, i, 1000).into())
                         .build(),
                 )
                 .build();
@@ -1804,15 +1804,15 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1820,7 +1820,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1830,9 +1830,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1841,7 +1841,7 @@ mod tests {
         let block0 = BlockBuilder::default()
             .transaction(cellbase0.clone())
             .transaction(tx00.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1850,7 +1850,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1861,9 +1861,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1874,11 +1874,11 @@ mod tests {
             .transaction(tx10)
             .header(
                 HeaderBuilder::default()
-                    .number(1.pack())
+                    .number(1.into())
                     .parent_hash(block0.hash())
                     .epoch(
                         EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .pack(),
+                            .into(),
                     )
                     .build(),
             )
@@ -1958,27 +1958,27 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1986,7 +1986,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1996,9 +1996,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2007,9 +2007,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2019,7 +2019,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
         indexer.append(&block0).unwrap();
         let (tip_number, tip_hash) = indexer.tip().unwrap().unwrap();
@@ -2031,7 +2031,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -2042,9 +2042,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2054,9 +2054,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2)
-                    .type_(Some(type_script2).pack())
+                    .type_(Some(type_script2).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2068,11 +2068,11 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1.pack())
+                    .number(1.into())
                     .parent_hash(block0.hash())
                     .epoch(
                         EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .pack(),
+                            .into(),
                     )
                     .build(),
             )
@@ -2126,27 +2126,27 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -2154,7 +2154,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -2164,9 +2164,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2175,9 +2175,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2187,7 +2187,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
         indexer.append(&block0).unwrap();
         let (tip_number, tip_hash) = indexer.tip().unwrap().unwrap();
@@ -2213,7 +2213,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -2224,9 +2224,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2236,9 +2236,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2)
-                    .type_(Some(type_script2).pack())
+                    .type_(Some(type_script2).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -2250,11 +2250,11 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1.pack())
+                    .number(1.into())
                     .parent_hash(block0.hash())
                     .epoch(
                         EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .pack(),
+                            .into(),
                     )
                     .build(),
             )
diff --git a/util/indexer/src/service.rs b/util/indexer/src/service.rs
index 849bb434c2..13fb68f821 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")
-                .unpack(),
+                .into(),
             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().unpack();
+                    let capacity: core::Capacity = output.capacity().into();
                     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")
-                    .unpack();
+                    .into();
                 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.unpack(),
+                        tx_hash: tx_hash.into(),
                         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().unpack();
+                    let capacity: core::Capacity = output.capacity().into();
                     if capacity < r0 || capacity >= r1 {
                         return None;
                     }
@@ -775,7 +775,7 @@ impl IndexerHandle {
                     }
                 }
 
-                Some(Unpack::<core::Capacity>::unpack(&output.capacity()).as_u64())
+                Some(Into::<core::Capacity>::into(&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")
-                .unpack(),
+                .into(),
             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()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).pack())
+            .args(Bytes::from(b"lock_script2".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).pack())
+            .args(Bytes::from(b"type_script2".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -982,7 +982,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -992,9 +992,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1003,9 +1003,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1015,7 +1015,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1028,20 +1028,20 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Bytes::from(i.to_string()).pack())
+                .output_data(Bytes::from(i.to_string()).into())
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()).pack())
+                        .type_(Some(type_script1.clone()).into())
                         .build(),
                 )
                 .output_data(Default::default())
@@ -1051,9 +1051,9 @@ mod tests {
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000).pack())
+                        .capacity(capacity_bytes!(2000).into())
                         .lock(lock_script2.clone())
-                        .type_(Some(type_script2.clone()).pack())
+                        .type_(Some(type_script2.clone()).into())
                         .build(),
                 )
                 .output_data(Default::default())
@@ -1065,7 +1065,7 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).pack())
+                        .number((pre_block.number() + 1).into())
                         .parent_hash(pre_block.hash())
                         .epoch(
                             EpochNumberWithFraction::new(
@@ -1073,7 +1073,7 @@ mod tests {
                                 pre_block.number(),
                                 1000,
                             )
-                            .pack(),
+                            .into(),
                         )
                         .build(),
                 )
@@ -1084,7 +1084,7 @@ mod tests {
 
         // test get_tip rpc
         let tip = rpc.get_indexer_tip().unwrap().unwrap();
-        assert_eq!(Unpack::<H256>::unpack(&pre_block.hash()), tip.block_hash);
+        assert_eq!(Into::<H256>::into(&pre_block.hash()), tip.block_hash);
         assert_eq!(pre_block.number(), tip.block_number.value());
 
         // test get_cells rpc
@@ -1476,9 +1476,9 @@ mod tests {
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1542,27 +1542,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script11 = ScriptBuilder::default()
             .code_hash(lock_script1.code_hash())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script11".to_vec()).pack())
+            .args(Bytes::from(b"lock_script11".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script11 = ScriptBuilder::default()
             .code_hash(type_script1.code_hash())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script11".to_vec()).pack())
+            .args(Bytes::from(b"type_script11".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1570,7 +1570,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1580,9 +1580,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1591,9 +1591,9 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11.clone()).pack())
+                    .type_(Some(type_script11.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1603,7 +1603,7 @@ mod tests {
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1616,20 +1616,20 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Bytes::from(i.to_string()).pack())
+                .output_data(Bytes::from(i.to_string()).into())
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).pack())
+                        .capacity(capacity_bytes!(1000).into())
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()).pack())
+                        .type_(Some(type_script1.clone()).into())
                         .build(),
                 )
                 .output_data(Default::default())
@@ -1639,9 +1639,9 @@ mod tests {
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000).pack())
+                        .capacity(capacity_bytes!(2000).into())
                         .lock(lock_script11.clone())
-                        .type_(Some(type_script11.clone()).pack())
+                        .type_(Some(type_script11.clone()).into())
                         .build(),
                 )
                 .output_data(Default::default())
@@ -1653,7 +1653,7 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).pack())
+                        .number((pre_block.number() + 1).into())
                         .parent_hash(pre_block.hash())
                         .epoch(
                             EpochNumberWithFraction::new(
@@ -1661,7 +1661,7 @@ mod tests {
                                 pre_block.number(),
                                 1000,
                             )
-                            .pack(),
+                            .into(),
                         )
                         .build(),
                 )
@@ -1821,27 +1821,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .args(Bytes::from(b"lock_script1".to_vec()).into())
             .build();
 
         let lock_script11 = ScriptBuilder::default()
             .code_hash(lock_script1.code_hash())
             .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script11".to_vec()).pack())
+            .args(Bytes::from(b"lock_script11".to_vec()).into())
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
+            .code_hash(H256(rand::random()).into())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).pack())
+            .args(Bytes::from(b"type_script1".to_vec()).into())
             .build();
 
         let type_script11 = ScriptBuilder::default()
             .code_hash(type_script1.code_hash())
             .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script11".to_vec()).pack())
+            .args(Bytes::from(b"type_script11".to_vec()).into())
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1849,7 +1849,7 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
@@ -1859,9 +1859,9 @@ mod tests {
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1)
-                    .type_(Some(type_script1).pack())
+                    .type_(Some(type_script1).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1872,19 +1872,19 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11).pack())
+                    .type_(Some(type_script11).into())
                     .build(),
             )
-            .output_data(data.to_vec().pack())
+            .output_data(data.to_vec().into())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0.pack()).build())
+            .header(HeaderBuilder::default().number(0.into()).build())
             .build();
 
         indexer.append(&block0).unwrap();
diff --git a/util/jsonrpc-types/src/alert.rs b/util/jsonrpc-types/src/alert.rs
index bbb459830c..7c10afc782 100644
--- a/util/jsonrpc-types/src/alert.rs
+++ b/util/jsonrpc-types/src/alert.rs
@@ -86,17 +86,23 @@ impl From<Alert> for packed::Alert {
             signatures,
         } = json;
         let raw = packed::RawAlert::new_builder()
-            .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())
+            .id(id.into())
+            .cancel(cancel.into())
+            .min_version(min_version.into())
+            .max_version(max_version.into())
+            .priority(priority.into())
+            .notice_until(notice_until.into())
+            .message(message.into())
             .build();
         packed::Alert::new_builder()
             .raw(raw)
-            .signatures(signatures.into_iter().map(Into::into).pack())
+            .signatures(
+                signatures
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::Bytes>>()
+                    .into(),
+            )
             .build()
     }
 }
@@ -105,8 +111,8 @@ impl From<packed::Alert> for Alert {
     fn from(input: packed::Alert) -> Self {
         let raw = input.raw();
         Alert {
-            id: raw.id().unpack(),
-            cancel: raw.cancel().unpack(),
+            id: raw.id().into(),
+            cancel: raw.cancel().into(),
             min_version: raw
                 .as_reader()
                 .min_version()
@@ -117,8 +123,8 @@ impl From<packed::Alert> for Alert {
                 .max_version()
                 .to_opt()
                 .map(|b| unsafe { b.as_utf8_unchecked() }.to_owned()),
-            priority: raw.priority().unpack(),
-            notice_until: raw.notice_until().unpack(),
+            priority: raw.priority().into(),
+            notice_until: raw.notice_until().into(),
             message: unsafe { raw.as_reader().message().as_utf8_unchecked() }.to_owned(),
             signatures: input.signatures().into_iter().map(Into::into).collect(),
         }
@@ -129,9 +135,9 @@ impl From<packed::Alert> for AlertMessage {
     fn from(input: packed::Alert) -> Self {
         let raw = input.raw();
         AlertMessage {
-            id: raw.id().unpack(),
-            priority: raw.priority().unpack(),
-            notice_until: raw.notice_until().unpack(),
+            id: raw.id().into(),
+            priority: raw.priority().into(),
+            notice_until: raw.notice_until().into(),
             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 8e49f9bf72..908abc66e5 100644
--- a/util/jsonrpc-types/src/block_template.rs
+++ b/util/jsonrpc-types/src/block_template.rs
@@ -115,12 +115,12 @@ impl From<BlockTemplate> for packed::Block {
             ..
         } = block_template;
         let raw = packed::RawHeader::new_builder()
-            .version(version.pack())
-            .compact_target(compact_target.pack())
-            .parent_hash(parent_hash.pack())
-            .timestamp(current_time.pack())
-            .number(number.pack())
-            .epoch(epoch.pack())
+            .version(version.into())
+            .compact_target(compact_target.into())
+            .parent_hash(parent_hash.into())
+            .timestamp(current_time.into())
+            .number(number.into())
+            .epoch(epoch.into())
             .dao(dao.into())
             .build();
         let header = packed::Header::new_builder().raw(raw).build();
@@ -137,7 +137,7 @@ impl From<BlockTemplate> for packed::Block {
                         .into_iter()
                         .map(|u| u.into())
                         .collect::<Vec<packed::UncleBlock>>()
-                        .pack(),
+                        .into(),
                 )
                 .transactions(txs)
                 .proposals(
@@ -145,7 +145,7 @@ impl From<BlockTemplate> for packed::Block {
                         .into_iter()
                         .map(|p| p.into())
                         .collect::<Vec<packed::ProposalShortId>>()
-                        .pack(),
+                        .into(),
                 )
                 .extension(extension)
                 .build()
@@ -158,7 +158,7 @@ impl From<BlockTemplate> for packed::Block {
                         .into_iter()
                         .map(|u| u.into())
                         .collect::<Vec<packed::UncleBlock>>()
-                        .pack(),
+                        .into(),
                 )
                 .transactions(txs)
                 .proposals(
@@ -166,7 +166,7 @@ impl From<BlockTemplate> for packed::Block {
                         .into_iter()
                         .map(|p| p.into())
                         .collect::<Vec<packed::ProposalShortId>>()
-                        .pack(),
+                        .into(),
                 )
                 .build()
         }
@@ -198,7 +198,13 @@ impl From<UncleTemplate> for packed::UncleBlock {
         } = template;
         packed::UncleBlock::new_builder()
             .header(header.into())
-            .proposals(proposals.into_iter().map(Into::into).pack())
+            .proposals(
+                proposals
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::ProposalShortId>>()
+                    .into(),
+            )
             .build()
     }
 }
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index e5812d1d9e..b9b0a15c9b 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -105,8 +105,8 @@ impl From<Script> for packed::Script {
         } = json;
         let hash_type: core::ScriptHashType = hash_type.into();
         packed::Script::new_builder()
-            .args(args.into_bytes().pack())
-            .code_hash(code_hash.pack())
+            .args(args.into_bytes().into())
+            .code_hash(code_hash.into())
             .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().unpack(),
-            args: JsonBytes::from_vec(input.args().unpack()),
+            code_hash: input.code_hash().into(),
+            args: JsonBytes::from_vec(input.args().into()),
             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().unpack(),
+            capacity: input.capacity().into(),
             lock: input.lock().into(),
             type_: input.type_().to_opt().map(Into::into),
         }
@@ -182,7 +182,7 @@ impl From<CellOutput> for packed::CellOutput {
         }
         .build();
         packed::CellOutput::new_builder()
-            .capacity(capacity.pack())
+            .capacity(capacity.into())
             .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().unpack();
+        let index: u32 = input.index().into();
         OutPoint {
-            tx_hash: input.tx_hash().unpack(),
+            tx_hash: input.tx_hash().into(),
             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.pack())
-            .index(index.pack())
+            .tx_hash(tx_hash.into())
+            .index(index.into())
             .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().unpack(),
+            since: input.since().into(),
         }
     }
 }
@@ -274,7 +274,7 @@ impl From<CellInput> for packed::CellInput {
         } = json;
         packed::CellInput::new_builder()
             .previous_output(previous_output.into())
-            .since(since.pack())
+            .since(since.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().unpack(),
+            version: raw.version().into(),
             cell_deps: raw.cell_deps().into_iter().map(Into::into).collect(),
             header_deps: raw
                 .header_deps()
                 .into_iter()
-                .map(|d| Unpack::<H256>::unpack(&d))
+                .map(|d| Into::<H256>::into(&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().unpack(),
+            hash: input.hash().into(),
         }
     }
 }
@@ -506,16 +506,52 @@ impl From<Transaction> for packed::Transaction {
             outputs_data,
         } = json;
         let raw = packed::RawTransaction::new_builder()
-            .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())
+            .version(version.into())
+            .cell_deps(
+                cell_deps
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::CellDep>>()
+                    .into(),
+            )
+            .header_deps(
+                header_deps
+                    .iter()
+                    .map(Pack::pack)
+                    .collect::<Vec<packed::Byte32>>()
+                    .into(),
+            )
+            .inputs(
+                inputs
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::CellInput>>()
+                    .into(),
+            )
+            .outputs(
+                outputs
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::CellOutput>>()
+                    .into(),
+            )
+            .outputs_data(
+                outputs_data
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::Bytes>>()
+                    .into(),
+            )
             .build();
         packed::Transaction::new_builder()
             .raw(raw)
-            .witnesses(witnesses.into_iter().map(Into::into).pack())
+            .witnesses(
+                witnesses
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::Bytes>>()
+                    .into(),
+            )
             .build()
     }
 }
@@ -784,17 +820,17 @@ impl From<packed::Header> for Header {
     fn from(input: packed::Header) -> Self {
         let raw = input.raw();
         Self {
-            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(),
+            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(),
             dao: raw.dao().into(),
-            nonce: input.nonce().unpack(),
+            nonce: input.nonce().into(),
         }
     }
 }
@@ -803,7 +839,7 @@ impl From<core::HeaderView> for HeaderView {
     fn from(input: core::HeaderView) -> Self {
         Self {
             inner: input.data().into(),
-            hash: input.hash().unpack(),
+            hash: input.hash().into(),
         }
     }
 }
@@ -831,20 +867,20 @@ impl From<Header> for packed::Header {
             nonce,
         } = json;
         let raw = packed::RawHeader::new_builder()
-            .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())
+            .version(version.into())
+            .parent_hash(parent_hash.into())
+            .timestamp(timestamp.into())
+            .number(number.into())
+            .epoch(epoch.into())
+            .transactions_root(transactions_root.into())
+            .proposals_hash(proposals_hash.into())
+            .compact_target(compact_target.into())
+            .extra_hash(extra_hash.into())
             .dao(dao.into())
             .build();
         packed::Header::new_builder()
             .raw(raw)
-            .nonce(nonce.pack())
+            .nonce(nonce.into())
             .build()
     }
 }
@@ -903,7 +939,7 @@ impl From<core::UncleBlockView> for UncleBlockView {
     fn from(input: core::UncleBlockView) -> Self {
         let header = HeaderView {
             inner: input.data().header().into(),
-            hash: input.hash().unpack(),
+            hash: input.hash().into(),
         };
         Self {
             header,
@@ -922,7 +958,13 @@ impl From<UncleBlock> for packed::UncleBlock {
         let UncleBlock { header, proposals } = json;
         packed::UncleBlock::new_builder()
             .header(header.into())
-            .proposals(proposals.into_iter().map(Into::into).pack())
+            .proposals(
+                proposals
+                    .into_iter()
+                    .map(Into::into)
+                    .collect::<Vec<packed::ProposalShortId>>()
+                    .into(),
+            )
             .build()
     }
 }
@@ -1029,7 +1071,7 @@ impl From<core::BlockView> for BlockView {
         let block = input.data();
         let header = HeaderView {
             inner: block.header().into(),
-            hash: input.hash().unpack(),
+            hash: input.hash().into(),
         };
         let uncles = block
             .uncles()
@@ -1038,7 +1080,7 @@ impl From<core::BlockView> for BlockView {
             .map(|(uncle, hash)| {
                 let header = HeaderView {
                     inner: uncle.header().into(),
-                    hash: hash.unpack(),
+                    hash: hash.into(),
                 };
                 UncleBlockView {
                     header,
@@ -1052,7 +1094,7 @@ impl From<core::BlockView> for BlockView {
             .zip(input.tx_hashes().iter())
             .map(|(tx, hash)| TransactionView {
                 inner: tx.into(),
-                hash: hash.unpack(),
+                hash: hash.into(),
             })
             .collect();
         Self {
@@ -1078,18 +1120,54 @@ impl From<Block> for packed::Block {
             let extension: packed::Bytes = extension.into();
             packed::BlockV1::new_builder()
                 .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())
+                .uncles(
+                    uncles
+                        .into_iter()
+                        .map(Into::into)
+                        .collect::<Vec<packed::UncleBlock>>()
+                        .into(),
+                )
+                .transactions(
+                    transactions
+                        .into_iter()
+                        .map(Into::into)
+                        .collect::<Vec<packed::Transaction>>()
+                        .into(),
+                )
+                .proposals(
+                    proposals
+                        .into_iter()
+                        .map(Into::into)
+                        .collect::<Vec<packed::ProposalShortId>>()
+                        .into(),
+                )
                 .extension(extension)
                 .build()
                 .as_v0()
         } else {
             packed::Block::new_builder()
                 .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())
+                .uncles(
+                    uncles
+                        .into_iter()
+                        .map(Into::into)
+                        .collect::<Vec<packed::UncleBlock>>()
+                        .into(),
+                )
+                .transactions(
+                    transactions
+                        .into_iter()
+                        .map(Into::into)
+                        .collect::<Vec<packed::Transaction>>()
+                        .into(),
+                )
+                .proposals(
+                    proposals
+                        .into_iter()
+                        .map(Into::into)
+                        .collect::<Vec<packed::ProposalShortId>>()
+                        .into(),
+                )
                 .build()
         }
     }
@@ -1160,10 +1238,10 @@ impl EpochView {
     /// Creates the view from the stored ext.
     pub fn from_ext(ext: packed::EpochExt) -> EpochView {
         EpochView {
-            number: ext.number().unpack(),
-            start_number: ext.start_number().unpack(),
-            length: ext.length().unpack(),
-            compact_target: ext.compact_target().unpack(),
+            number: ext.number().into(),
+            start_number: ext.start_number().into(),
+            length: ext.length().into(),
+            compact_target: ext.compact_target().into(),
         }
     }
 }
@@ -1257,7 +1335,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.unpack(),
+            finalized_at: core.finalized_at.into(),
         }
     }
 }
@@ -1268,7 +1346,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.pack(),
+            finalized_at: json.finalized_at.into(),
         }
     }
 }
diff --git a/util/jsonrpc-types/src/bytes.rs b/util/jsonrpc-types/src/bytes.rs
index b5b7a6bcf4..555a34b8ce 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, prelude::*};
+use ckb_types::{bytes::Bytes, packed};
 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.pack()
+        input.0.into()
     }
 }
 
diff --git a/util/jsonrpc-types/src/cell.rs b/util/jsonrpc-types/src/cell.rs
index 887dbc2ab8..6a5d8c8061 100644
--- a/util/jsonrpc-types/src/cell.rs
+++ b/util/jsonrpc-types/src/cell.rs
@@ -1,7 +1,6 @@
 use crate::{CellOutput, JsonBytes};
 use ckb_types::{
     core::cell::{CellMeta, CellStatus},
-    prelude::Unpack,
     H256,
 };
 use schemars::JsonSchema;
@@ -126,7 +125,7 @@ impl From<CellMeta> for CellInfo {
             data: data.and_then(move |data| {
                 data_hash.map(|hash| CellData {
                     content: JsonBytes::from_bytes(data),
-                    hash: hash.unpack(),
+                    hash: hash.into(),
                 })
             }),
         }
diff --git a/util/jsonrpc-types/src/pool.rs b/util/jsonrpc-types/src/pool.rs
index b3d9ea8c7a..a0b950d74e 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.unpack(),
+            tip_hash: tx_pool_info.tip_hash.into(),
             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.unpack(), entry.into()))
+                .map(|(hash, entry)| (hash.into(), entry.into()))
                 .collect(),
             proposed: proposed
                 .into_iter()
-                .map(|(hash, entry)| (hash.unpack(), entry.into()))
+                .map(|(hash, entry)| (hash.into(), 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 3afb79d628..0e480c8a32 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().pack()
+        json.into_inner().into()
     }
 }
 
diff --git a/util/jsonrpc-types/src/tests/blockchain.rs b/util/jsonrpc-types/src/tests/blockchain.rs
index a82be1a06b..2a2fefe79b 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.pack())
+        .args(arg.into())
         .hash_type(core::ScriptHashType::Data.into())
         .build()
 }
 
 fn mock_cell_output(arg: Bytes) -> packed::CellOutput {
     packed::CellOutputBuilder::default()
-        .capacity(core::Capacity::zero().pack())
+        .capacity(core::Capacity::zero().into())
         .lock(packed::Script::default())
-        .type_(Some(mock_script(arg)).pack())
+        .type_(Some(mock_script(arg)).into())
         .build()
 }
 
@@ -32,14 +32,16 @@ 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.pack()])
-        .witness(arg.pack())
+        .outputs_data(vec![data.into()])
+        .witness(arg.into())
         .build()
 }
 
 fn mock_uncle() -> core::UncleBlockView {
     core::BlockBuilder::default()
-        .proposals(vec![packed::ProposalShortId::default()].pack())
+        .proposals(Into::<packed::ProposalShortIdVec>::into(vec![
+            packed::ProposalShortId::default(),
+        ]))
         .build()
         .as_uncle()
 }
diff --git a/util/jsonrpc-types/src/uints.rs b/util/jsonrpc-types/src/uints.rs
index 7889860140..8e7b9c8470 100644
--- a/util/jsonrpc-types/src/uints.rs
+++ b/util/jsonrpc-types/src/uints.rs
@@ -140,6 +140,27 @@ 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) => {
@@ -167,6 +188,10 @@ 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 f9549838e6..5a04b7bfe9 100644
--- a/util/launcher/Cargo.toml
+++ b/util/launcher/Cargo.toml
@@ -33,6 +33,10 @@ ckb-light-client-protocol-server = { path = "../light-client-protocol-server", v
 ckb-block-filter = { path = "../../block-filter", version = "= 0.118.0-pre" }
 
 [features]
-with_sentry = ["ckb-sync/with_sentry", "ckb-network/with_sentry", "ckb-app-config/with_sentry"]
+with_sentry = [
+    "ckb-sync/with_sentry",
+    "ckb-network/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 1598953e25..b22d3fa401 100644
--- a/util/launcher/src/lib.rs
+++ b/util/launcher/src/lib.rs
@@ -27,7 +27,6 @@ use ckb_shared::shared_builder::{SharedBuilder, SharedPackage};
 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;
@@ -97,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.pack())?)
+                    && check_lock_code_hash(&(&block_assembler.code_hash).into())?)
             {
                 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 991852309c..547300d2bd 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.pack(),
-                uncles_hash.pack(),
+                block_headers.into(),
+                uncles_hash.into(),
                 packed::BytesOptVec::new_builder().set(extensions).build(),
             );
-            let missing_items = missing.pack();
+            let missing_items = missing.into();
 
             self.protocol.reply_proof::<packed::SendBlocksProofV1>(
                 self.peer,
@@ -111,8 +111,8 @@ impl<'a> GetBlocksProofProcess<'a> {
                 missing_items,
             )
         } else {
-            let proved_items = block_headers.pack();
-            let missing_items = missing.pack();
+            let proved_items = block_headers.into();
+            let missing_items = missing.into();
 
             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 d6bc3791a7..643586890c 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().unpack();
+        let subscribe: bool = self.message.subscribe().into();
         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 c64592db89..1d74a1fd02 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(Pack::pack(&extension))
+                    .extension(Into::into(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().unpack();
+        let last_n_blocks: u64 = self.message.last_n_blocks().into();
 
         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().unpack();
-        let difficulty_boundary: U256 = self.message.difficulty_boundary().unpack();
+        let start_block_number: BlockNumber = self.message.start_number().into();
+        let difficulty_boundary: U256 = self.message.difficulty_boundary().into();
         let mut difficulties = self
             .message
             .difficulties()
             .iter()
-            .map(|d| Unpack::<U256>::unpack(&d))
+            .map(Into::<U256>::into)
             .collect::<Vec<_>>();
 
         let last_block_number = last_block.number();
@@ -356,7 +356,7 @@ impl<'a> GetLastStateProofProcess<'a> {
             (positions, headers)
         };
 
-        let proved_items = headers.pack();
+        let proved_items = headers.into();
 
         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 1dd5700b53..e0e7a71f5d 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.pack())
+                .transactions(txs.into())
                 .proof(
                     packed::MerkleProof::new_builder()
-                        .indices(merkle_proof.indices().to_owned().pack())
-                        .lemmas(merkle_proof.lemmas().to_owned().pack())
+                        .indices(merkle_proof.indices().into())
+                        .lemmas(merkle_proof.lemmas().to_owned().into())
                         .build(),
                 )
                 .build();
@@ -131,10 +131,10 @@ impl<'a> GetTransactionsProofProcess<'a> {
                 packed::FilteredBlockVec::new_builder()
                     .set(filtered_blocks)
                     .build(),
-                uncles_hash.pack(),
+                uncles_hash.into(),
                 packed::BytesOptVec::new_builder().set(extensions).build(),
             );
-            let missing_items = missing.pack();
+            let missing_items = missing.into();
 
             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.pack();
+            let missing_items = missing.into();
 
             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 d2e6bd938e..d049ee3953 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(Pack::pack(&tip_block.extension()))
+            .extension(Into::into(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(Pack::pack(&last_block.extension()))
+            .extension(Into::into(last_block.extension()))
             .parent_chain_root(parent_chain_root)
             .build();
         let content = T::new_builder()
             .set_last_header(verifiable_last_header)
-            .set_proof(proof.pack())
+            .set_proof(proof.into())
             .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 a0dc24885e..e17fbfb4cf 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.pack());
+        .map(|h| h.into());
         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.pack())
+            .block_hashes(request_block_hashes.into())
             .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 6507668741..693f032442 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.pack())
-            .last_n_blocks(10u64.pack())
-            .difficulty_boundary(genesis_header.difficulty().pack())
+            .start_number(0u64.into())
+            .last_n_blocks(10u64.into())
+            .difficulty_boundary(genesis_header.difficulty().into())
             .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().unpack());
+            let mmr_size = leaf_index_to_mmr_size(parent_chain_root.end_number().into());
             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 eb8e280646..b70a1db9c1 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.pack()];
+    let expected_missing_tx_hashes = vec![tx2.hash(), (&tx3_hash).into()];
 
     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.pack()].pack())
+            .tx_hashes(vec![tx1.hash(), tx2.hash(), tx3_hash.into()].into())
             .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 3fc94a7068..1e578f2712 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(Pack::pack(&block.extension()))
+                .extension(Into::into(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 03e37e704b..289b36bb75 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.pack())
+            .output_data(always_success_cell_data.into())
             .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().pack())
-                .compact_target(DIFF_TWO.pack())
+                .timestamp(unix_time_as_millis().into())
+                .compact_target(DIFF_TWO.into())
                 .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().unpack(),
+                code_hash: always_success_script.code_hash().into(),
                 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().unpack();
+        let input_capacity: Capacity = cellbase.output(0).unwrap().capacity().into();
         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.pack())
+            .capacity(output_capacity.into())
             .lock(always_success_script.to_owned())
             .build();
         TransactionView::new_advanced_builder()
diff --git a/util/migrate/src/migrations/add_number_hash_mapping.rs b/util/migrate/src/migrations/add_number_hash_mapping.rs
index cf07ead605..e752957e4b 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.pack();
+                    let block_number: packed::Uint64 = number.into();
                     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).pack();
+                    let raw_txs_len: packed::Uint32 = (txs_len as u32).into();
 
                     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 7dee3fc991..f01d80012b 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.pack())
+                        .index(index.into())
                         .build();
 
                     let entry = packed::CellEntryBuilder::default()
                         .output(cell_output)
                         .block_hash(block_hash.clone())
-                        .block_number(block_number.pack())
-                        .block_epoch(block_epoch.pack())
-                        .index(tx_index.pack())
-                        .data_size((data.len() as u64).pack())
+                        .block_number(block_number.into())
+                        .block_epoch(block_epoch.into())
+                        .index(tx_index.into())
+                        .data_size((data.len() as u64).into())
                         .build();
 
                     let data_entry = if !data.is_empty() {
                         let data_hash = packed::CellOutput::calc_data_hash(&data);
                         Some(
                             packed::CellDataEntryBuilder::default()
-                                .output_data(data.pack())
+                                .output_data(data.into())
                                 .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 e45f6fd253..58c4773d90 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, Pack, Reader},
+    prelude::{Entity, FromSliceShouldBeOk, 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.pack();
+        let hard_fork_epoch_number: packed::Uint64 = limit_epoch.into();
         let tip_header = chain_db.get_tip_header().expect("db must have tip header");
-        let tip_epoch_number = tip_header.epoch().pack();
+        let tip_epoch_number: packed::Uint64 = tip_header.epoch().into();
 
         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 f8335c6fc0..93b41cf8e8 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 = genesis.header().pack();
+        let header: packed::HeaderView = genesis.header().into();
         let number = header.data().raw().number();
-        let uncles = genesis.uncles().pack();
+        let uncles: packed::UncleBlockVecView = genesis.uncles().into();
         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.pack())
+                .index(index.into())
                 .build();
-            let tx_data = tx.pack();
+            let tx_data: packed::TransactionView = tx.into();
             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(),
-                epoch_ext.pack().as_slice(),
+                Into::<packed::EpochExt>::into(&epoch_ext).as_slice(),
             )
             .unwrap();
-        let epoch_number: packed::Uint64 = epoch_ext.number().pack();
+        let epoch_number: packed::Uint64 = epoch_ext.number().into();
         db_txn
             .put(
                 COLUMN_EPOCH,
@@ -130,7 +130,7 @@ fn test_mock_migration() {
             .put(
                 COLUMN_BLOCK_EXT,
                 genesis.header().hash().as_slice(),
-                ext.pack().as_slice(),
+                Into::<packed::BlockExtV1>::into(ext).as_slice(),
             )
             .unwrap()
     }
@@ -141,7 +141,7 @@ fn test_mock_migration() {
             .put(
                 COLUMN_META,
                 META_CURRENT_EPOCH_KEY,
-                epoch_ext.pack().as_slice(),
+                Into::<packed::EpochExt>::into(epoch_ext).as_slice(),
             )
             .unwrap()
     }
diff --git a/util/network-alert/src/alert_relayer.rs b/util/network-alert/src/alert_relayer.rs
index e4b8f506c8..305af17771 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().unpack();
+            let alert_id: u32 = alert.as_reader().raw().id().into();
             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().unpack();
+        let alert_id = alert.as_reader().raw().id().into();
         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 363d5b45e3..d684f149a3 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, prelude::*};
+use ckb_types::packed::Alert;
 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().unpack();
-        let alert_cancel = alert.raw().cancel().unpack();
+        let alert_id = alert.raw().id().into();
+        let alert_cancel = alert.raw().cancel().into();
         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().unpack();
+            let priority: u32 = a.raw().priority().into();
             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().unpack();
+            let id: u32 = a.raw().id().into();
             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().unpack();
+            let notice_until: u64 = alert.raw().notice_until().into();
             notice_until > now
         });
         self.noticed_alerts.retain(|a| {
-            let notice_until: u64 = a.raw().notice_until().unpack();
+            let notice_until: u64 = a.raw().notice_until().into();
             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 366e9ef068..028b65a1c7 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.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())
+        .notice_until(1681574400000u64.into())
+        .id(20230001u32.into())
+        .cancel(0u32.into())
+        .priority(20u32.into())
+        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.".into())
+        .min_version(Some("0.105.0-pre").into())
+        .max_version(Some("0.105.1").into())
         .build();
 
     let hash = raw_alert.calc_alert_hash();
     let privkey = DUMMY_PRIVKEY.parse::<Privkey>().unwrap();
-    let signature = privkey
-        .sign_recoverable(&hash.unpack())
+    let signature: packed::Bytes = privkey
+        .sign_recoverable(&(&hash).into())
         .unwrap()
         .serialize()
-        .pack();
+        .into();
     let alert = packed::Alert::new_builder()
         .raw(raw_alert)
-        .signatures(vec![signature.clone()].pack())
+        .signatures(vec![signature.clone()].into())
         .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.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())
+        .notice_until(1681574400000u64.into())
+        .id(20230001u32.into())
+        .cancel(0u32.into())
+        .priority(20u32.into())
+        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.".into())
+        .min_version(Some("0.105.0-pre").into())
+        .max_version(Some("0.105.1").into())
         .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.pack()
+        buf.into()
     }).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 86c77b0982..ea0654861a 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.pack())
-        .cancel(cancel.pack())
-        .min_version(min_ver.pack())
-        .max_version(max_ver.pack())
-        .notice_until(notice_until.pack())
+        .id(id.into())
+        .cancel(cancel.into())
+        .min_version(min_ver.into())
+        .max_version(max_ver.into())
+        .notice_until(notice_until.into())
         .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 6060eb70d6..0b86c88b21 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.pack()).build();
+    let raw_alert = packed::RawAlert::new_builder().id(1u32.into()).build();
     let hash = raw_alert.calc_alert_hash();
     let signatures = keypairs
         .iter()
-        .map(|(privkey, _)| privkey.sign_recoverable(&hash.unpack()))
+        .map(|(privkey, _)| privkey.sign_recoverable(&(&hash).into()))
         .collect::<Result<Vec<_>, _>>()
         .expect("sign alert")
         .iter()
-        .map(|sig| sig.serialize().pack())
+        .map(|sig| sig.serialize().into())
         .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 6ab899fbf9..72b2494f7d 100644
--- a/util/reward-calculator/src/tests.rs
+++ b/util/reward-calculator/src/tests.rs
@@ -6,7 +6,6 @@ use ckb_store::{ChainDB, ChainStore};
 use ckb_types::{
     core::{BlockBuilder, BlockExt, EpochNumberWithFraction, HeaderBuilder, TransactionBuilder},
     packed::ProposalShortId,
-    prelude::*,
 };
 use std::collections::HashSet;
 use tempfile::TempDir;
@@ -129,12 +128,12 @@ fn test_proposal_reward() {
         .tx_proposal_window(ProposalWindow(2, 5))
         .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 tx1 = TransactionBuilder::default().version(100u32.into()).build();
+    let tx2 = TransactionBuilder::default().version(200u32.into()).build();
+    let tx3 = TransactionBuilder::default().version(300u32.into()).build();
+    let tx4 = TransactionBuilder::default().version(400u32.into()).build();
+    let tx5 = TransactionBuilder::default().version(500u32.into()).build();
+    let tx6 = TransactionBuilder::default().version(600u32.into()).build();
 
     let p1 = tx1.proposal_short_id();
     let p2 = tx2.proposal_short_id();
@@ -146,8 +145,8 @@ fn test_proposal_reward() {
     let block_10 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(10u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 10, 1000).pack())
+                .number(10u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 10, 1000).into())
                 .build(),
         )
         .proposal(p1.clone())
@@ -160,8 +159,8 @@ fn test_proposal_reward() {
     let block_11 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(11u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 11, 1000).pack())
+                .number(11u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 11, 1000).into())
                 .parent_hash(block_10.hash())
                 .build(),
         )
@@ -172,8 +171,8 @@ fn test_proposal_reward() {
     let block_12 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(12u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 12, 1000).pack())
+                .number(12u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 12, 1000).into())
                 .parent_hash(block_11.hash())
                 .build(),
         )
@@ -183,8 +182,8 @@ fn test_proposal_reward() {
     let block_13 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(13u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 13, 1000).pack())
+                .number(13u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 13, 1000).into())
                 .parent_hash(block_12.hash())
                 .build(),
         )
@@ -195,8 +194,8 @@ fn test_proposal_reward() {
     let block_14 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(14u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 14, 1000).pack())
+                .number(14u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 14, 1000).into())
                 .parent_hash(block_13.hash())
                 .build(),
         )
@@ -208,8 +207,8 @@ fn test_proposal_reward() {
     let block_15 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(15u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 15, 1000).pack())
+                .number(15u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 15, 1000).into())
                 .parent_hash(block_14.hash())
                 .build(),
         )
@@ -219,8 +218,8 @@ fn test_proposal_reward() {
     let block_16 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(16u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 16, 1000).pack())
+                .number(16u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 16, 1000).into())
                 .parent_hash(block_15.hash())
                 .build(),
         )
@@ -228,8 +227,8 @@ fn test_proposal_reward() {
     let block_17 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(17u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 17, 1000).pack())
+                .number(17u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 17, 1000).into())
                 .parent_hash(block_16.hash())
                 .build(),
         )
@@ -237,8 +236,8 @@ fn test_proposal_reward() {
     let block_18 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(18u64.pack())
-                .epoch(EpochNumberWithFraction::new(1, 18, 1000).pack())
+                .number(18u64.into())
+                .epoch(EpochNumberWithFraction::new(1, 18, 1000).into())
                 .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 9c8831b347..3fe3f19153 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().unpack();
+    let output_index: u32 = out_point.index().into();
 
     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().unpack();
+    let output_index: u32 = out_point.index().into();
 
     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().unpack();
+    let cell_capacity: u64 = cell.capacity().into();
     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().unpack();
+    let since: u64 = input.since().into();
     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]).pack());
+        lock_builder = lock_builder.code_hash(to_fixed_array::<32>(&lock_code_hash[0..32]).into());
     }
     if let Some(lock_args) = lock_args {
-        lock_builder = lock_builder.args(lock_args.pack());
+        lock_builder = lock_builder.args(lock_args.into());
     }
     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]).pack());
+        type_builder = type_builder.code_hash(to_fixed_array::<32>(&type_code_hash[0..32]).into());
     }
     if let Some(type_args) = type_args {
-        type_builder = type_builder.args(type_args.pack());
+        type_builder = type_builder.args(type_args.into());
     }
     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).pack())
+        .capacity((capacity as u64).into())
         .lock(lock_script)
-        .type_(Some(type_script).pack())
+        .type_(Some(type_script).into())
         .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 32c395f775..365e8c5040 100644
--- a/util/rich-indexer/src/indexer/mod.rs
+++ b/util/rich-indexer/src/indexer/mod.rs
@@ -11,7 +11,6 @@ use ckb_indexer_sync::{CustomFilters, Error, IndexerSync, Pool};
 use ckb_types::{
     core::{BlockNumber, BlockView, TransactionView},
     packed::Byte32,
-    prelude::*,
     H256,
 };
 use sqlx::{Any, Transaction};
@@ -68,7 +67,7 @@ impl IndexerSync for RichIndexer {
         );
         indexer_handle
             .get_indexer_tip()
-            .map(|tip| tip.map(|tip| (tip.block_number.value(), tip.block_hash.0.pack())))
+            .map(|tip| tip.map(|tip| (tip.block_number.value(), tip.block_hash.0.into())))
             .map_err(|err| Error::DB(err.to_string()))
     }
 
@@ -190,7 +189,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.pack())
+                .is_cell_filter_match(&cell, &(&data).into())
             {
                 build_output_cell_rows(&cell, output_index, &data, &mut output_cell_rows);
                 build_script_set(&cell, &mut script_set).await;
@@ -207,7 +206,7 @@ impl AsyncRichIndexer {
                     {
                         if self
                             .custom_filters
-                            .is_cell_filter_match(&output, &output_data.pack())
+                            .is_cell_filter_match(&output, &output_data.into())
                         {
                             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 100a5eaca0..efa7ecfe5c 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().unpack();
-                    (tx_hash.as_bytes().to_vec(), out_point.index().unpack())
+                    let tx_hash: H256 = out_point.tx_hash().into();
+                    (tx_hash.as_bytes().to_vec(), out_point.index().into())
                 })
                 .collect::<Vec<(_, u32)>>()
         }
@@ -249,28 +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")).pack())
-        .index((row.get::<i32, _>("output_index") as u32).pack())
+        .tx_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("tx_hash")).into())
+        .index((row.get::<i32, _>("output_index") as u32).into())
         .build();
     let lock_script = ScriptBuilder::default()
-        .code_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("lock_code_hash")).pack())
+        .code_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("lock_code_hash")).into())
         .hash_type((row.get::<i16, _>("lock_hash_type") as u8).into())
-        .args(row.get::<Vec<u8>, _>("lock_args").pack())
+        .args(row.get::<Vec<u8>, _>("lock_args").into())
         .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).pack())
+                .code_hash(to_fixed_array::<32>(value).into())
                 .hash_type((row.get::<Option<i16>, _>("type_hash_type").unwrap() as u8).into())
-                .args(row.get::<Option<Vec<u8>>, _>("type_args").unwrap().pack())
+                .args(row.get::<Option<Vec<u8>>, _>("type_args").unwrap().into())
                 .build()
         });
     let output = CellOutputBuilder::default()
-        .capacity((row.get::<i64, _>("capacity") as u64).pack())
+        .capacity((row.get::<i64, _>("capacity") as u64).into())
         .lock(lock_script)
-        .type_(type_script.pack())
+        .type_(type_script.into())
         .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 5a14d90592..6b87b2681b 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,7 +5,6 @@ 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;
 
@@ -83,8 +82,8 @@ impl AsyncRichIndexerHandle {
             dead_cells = pool
                 .dead_cells()
                 .map(|out_point| {
-                    let tx_hash: H256 = out_point.tx_hash().unpack();
-                    (tx_hash.as_bytes().to_vec(), out_point.index().unpack())
+                    let tx_hash: H256 = out_point.tx_hash().into();
+                    (tx_hash.as_bytes().to_vec(), out_point.index().into())
                 })
                 .collect::<Vec<(_, u32)>>()
         }
diff --git a/util/rich-indexer/src/tests/insert.rs b/util/rich-indexer/src/tests/insert.rs
index 1c8fc9e26a..2628a4e082 100644
--- a/util/rich-indexer/src/tests/insert.rs
+++ b/util/rich-indexer/src/tests/insert.rs
@@ -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()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).pack())
+        .args(Bytes::from(b"lock_script1".to_vec()).into())
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script2".to_vec()).pack())
+        .args(Bytes::from(b"lock_script2".to_vec()).into())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).pack())
+        .args(Bytes::from(b"type_script1".to_vec()).into())
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"type_script2".to_vec()).pack())
+        .args(Bytes::from(b"type_script2".to_vec()).into())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -109,7 +109,7 @@ async fn with_custom_block_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -119,9 +119,9 @@ async fn with_custom_block_filter() {
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).pack())
+                .type_(Some(type_script1.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -130,9 +130,9 @@ async fn with_custom_block_filter() {
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()).pack())
+                .type_(Some(type_script2.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -142,19 +142,19 @@ async fn with_custom_block_filter() {
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.pack()).build())
+        .header(HeaderBuilder::default().number(0.into()).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.pack());
+    assert_eq!(block0.hash(), tip.block_hash.into());
 
     let cellbase1 = TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(1))
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -165,9 +165,9 @@ async fn with_custom_block_filter() {
         .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1).pack())
+                .type_(Some(type_script1).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -177,9 +177,9 @@ async fn with_custom_block_filter() {
         .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script2)
-                .type_(Some(type_script2).pack())
+                .type_(Some(type_script2).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -191,10 +191,10 @@ async fn with_custom_block_filter() {
         .transaction(tx11)
         .header(
             HeaderBuilder::default()
-                .number(1.pack())
+                .number(1.into())
                 .parent_hash(block0.hash())
                 .epoch(
-                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).pack(),
+                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).into(),
                 )
                 .build(),
         )
@@ -203,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.pack());
+    assert_eq!(block1.hash(), tip.block_hash.into());
     assert_eq!(
         2, // cellbase1, tx10
         indexer_handle
@@ -244,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.pack());
+    assert_eq!(block0.hash(), tip.block_hash.into());
     assert_eq!(
         0,
         indexer_handle
@@ -295,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()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).pack())
+        .args(Bytes::from(b"lock_script1".to_vec()).into())
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script2".to_vec()).pack())
+        .args(Bytes::from(b"lock_script2".to_vec()).into())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).pack())
+        .args(Bytes::from(b"type_script1".to_vec()).into())
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"type_script2".to_vec()).pack())
+        .args(Bytes::from(b"type_script2".to_vec()).into())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -323,7 +323,7 @@ async fn with_custom_cell_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -333,9 +333,9 @@ async fn with_custom_cell_filter() {
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).pack())
+                .type_(Some(type_script1.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -344,9 +344,9 @@ async fn with_custom_cell_filter() {
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()).pack())
+                .type_(Some(type_script2.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -356,12 +356,12 @@ async fn with_custom_cell_filter() {
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.pack()).build())
+        .header(HeaderBuilder::default().number(0.into()).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.pack());
+    assert_eq!(block0.hash(), tip.block_hash.into());
     assert_eq!(
         1, // cellbase1, tx00
         indexer_handle
@@ -402,7 +402,7 @@ async fn with_custom_cell_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -413,9 +413,9 @@ async fn with_custom_cell_filter() {
         .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1).pack())
+                .type_(Some(type_script1).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -425,9 +425,9 @@ async fn with_custom_cell_filter() {
         .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script2)
-                .type_(Some(type_script2).pack())
+                .type_(Some(type_script2).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -439,10 +439,10 @@ async fn with_custom_cell_filter() {
         .transaction(tx11)
         .header(
             HeaderBuilder::default()
-                .number(1.pack())
+                .number(1.into())
                 .parent_hash(block0.hash())
                 .epoch(
-                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).pack(),
+                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).into(),
                 )
                 .build(),
         )
@@ -451,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.pack());
+    assert_eq!(block1.hash(), tip.block_hash.into());
     assert_eq!(
         1, // tx10
         indexer_handle
@@ -492,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.pack());
+    assert_eq!(block0.hash(), tip.block_hash.into());
     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 8adcba4aeb..dfeee1a0f4 100644
--- a/util/rich-indexer/src/tests/query.rs
+++ b/util/rich-indexer/src/tests/query.rs
@@ -45,13 +45,13 @@ async fn get_cells() {
 
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
         .args(
             hex::decode("62e907b15cbf27d5425399ebf6f0fb50ebb88f18")
                 .expect("Decoding failed")
-                .pack(),
+                .into(),
         )
         .build();
     let search_key = IndexerSearchKey {
@@ -70,10 +70,10 @@ async fn get_cells() {
 
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("62e907b15cbf").expect("Decoding failed").pack())
+        .args(hex::decode("62e907b15cbf").expect("Decoding failed").into())
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.into(),
@@ -97,7 +97,7 @@ async fn get_cells() {
             search_key,
             IndexerOrder::Asc,
             100u32.into(),
-            Some([5u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
+            Some(Into::<packed::Bytes>::into([5u8, 0, 0, 0, 0, 0, 0, 0]).into()),
         )
         .await
         .unwrap();
@@ -117,21 +117,21 @@ async fn get_cells() {
 
     let type_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").pack(),
+            h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").into(),
         )
         .hash_type((ScriptHashType::Type as u8).into())
         .args(
             h256!("0xb2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626")
                 .as_bytes()
-                .pack(),
+                .into(),
         )
         .build();
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
-        .args(vec![].as_slice().pack())
+        .args(vec![].as_slice().into())
         .build();
     let lock_script_len = extract_raw_data(&lock_script).len() as u64;
     let search_key = IndexerSearchKey {
@@ -156,7 +156,7 @@ async fn get_cells() {
             search_key,
             IndexerOrder::Asc,
             10u32.into(),
-            Some([1u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
+            Some(Into::<packed::Bytes>::into([1u8, 0, 0, 0, 0, 0, 0, 0]).into()),
         )
         .await
         .unwrap();
@@ -175,13 +175,13 @@ async fn get_cells_filter_data() {
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
             .code_hash(
-                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").pack(),
+                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").into(),
             )
             .hash_type((ScriptHashType::Type as u8).into())
             .args(
                 hex::decode("b2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626")
                     .expect("Decoding failed")
-                    .pack(),
+                    .into(),
             )
             .build()
             .into(),
@@ -201,7 +201,7 @@ async fn get_cells_filter_data() {
             search_key,
             IndexerOrder::Asc,
             100u32.into(),
-            Some([2u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
+            Some(Into::<packed::Bytes>::into([2u8, 0, 0, 0, 0, 0, 0, 0]).into()),
         )
         .await
         .unwrap();
@@ -230,10 +230,10 @@ async fn get_cells_by_cursor() {
 
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("").expect("Decoding failed").pack())
+        .args(hex::decode("").expect("Decoding failed").into())
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.clone().into(),
@@ -248,7 +248,7 @@ async fn get_cells_by_cursor() {
             search_key,
             IndexerOrder::Asc,
             3u32.into(),
-            Some([0u8, 0, 0, 0, 0, 0, 0, 0].pack().into()),
+            Some(Into::<packed::Bytes>::into([0u8, 0, 0, 0, 0, 0, 0, 0]).into()),
         )
         .await
         .unwrap();
@@ -290,10 +290,10 @@ async fn get_transactions_ungrouped() {
 
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("").expect("Decoding failed").pack())
+        .args(hex::decode("").expect("Decoding failed").into())
         .build();
 
     let search_key = IndexerSearchKey {
@@ -348,13 +348,13 @@ async fn get_transactions_ungrouped() {
 
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x709f3fda12f561cfacf92273c57a98fede188a3f1a59b1f888d113f9cce08649").pack(),
+            h256!("0x709f3fda12f561cfacf92273c57a98fede188a3f1a59b1f888d113f9cce08649").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
         .args(
             hex::decode("b73961e46d9eb118d3de1d1e8f30b3af7bbf3160")
                 .expect("Decoding failed")
-                .pack(),
+                .into(),
         )
         .build();
     let search_key = IndexerSearchKey {
@@ -414,10 +414,10 @@ async fn get_transactions_grouped() {
 
     let lock_script = ScriptBuilder::default()
         .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").pack(),
+            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
         )
         .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("").expect("Decoding failed").pack())
+        .args(hex::decode("").expect("Decoding failed").into())
         .build();
 
     let search_key = IndexerSearchKey {
@@ -496,13 +496,13 @@ async fn get_cells_capacity() {
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
             .code_hash(
-                h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8").pack(),
+                h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8").into(),
             )
             .hash_type((ScriptHashType::Type as u8).into())
             .args(
                 hex::decode("57ccb07be6875f61d93636b0ee11b675494627d2")
                     .expect("Decoding failed")
-                    .pack(),
+                    .into(),
             )
             .build()
             .into(),
@@ -527,13 +527,13 @@ async fn get_cells_capacity() {
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
             .code_hash(
-                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").pack(),
+                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").into(),
             )
             .hash_type((ScriptHashType::Type as u8).into())
             .args(
                 hex::decode("500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bc")
                     .expect("Decoding failed")
-                    .pack(),
+                    .into(),
             )
             .build()
             .into(),
@@ -564,27 +564,27 @@ async fn rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).pack())
+        .args(Bytes::from(b"lock_script1".to_vec()).into())
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script2".to_vec()).pack())
+        .args(Bytes::from(b"lock_script2".to_vec()).into())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).pack())
+        .args(Bytes::from(b"type_script1".to_vec()).into())
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"type_script2".to_vec()).pack())
+        .args(Bytes::from(b"type_script2".to_vec()).into())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -592,7 +592,7 @@ async fn rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -602,9 +602,9 @@ async fn rpc() {
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).pack())
+                .type_(Some(type_script1.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -613,9 +613,9 @@ async fn rpc() {
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()).pack())
+                .type_(Some(type_script2.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -625,7 +625,7 @@ async fn rpc() {
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.pack()).build())
+        .header(HeaderBuilder::default().number(0.into()).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
@@ -638,20 +638,20 @@ async fn rpc() {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Bytes::from(i.to_string()).pack())
+            .output_data(Bytes::from(i.to_string()).into())
             .build();
 
         pre_tx0 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -661,9 +661,9 @@ async fn rpc() {
             .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).pack())
+                    .type_(Some(type_script2.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -675,7 +675,7 @@ async fn rpc() {
             .transaction(pre_tx1.clone())
             .header(
                 HeaderBuilder::default()
-                    .number((pre_block.number() + 1).pack())
+                    .number((pre_block.number() + 1).into())
                     .parent_hash(pre_block.hash())
                     .epoch(
                         EpochNumberWithFraction::new(
@@ -683,7 +683,7 @@ async fn rpc() {
                             pre_block.number(),
                             1000,
                         )
-                        .pack(),
+                        .into(),
                     )
                     .build(),
             )
@@ -694,7 +694,7 @@ async fn rpc() {
 
     // test get_tip rpc
     let tip = rpc.get_indexer_tip().await.unwrap().unwrap();
-    assert_eq!(Unpack::<H256>::unpack(&pre_block.hash()), tip.block_hash);
+    assert_eq!(Into::<H256>::into(&pre_block.hash()), tip.block_hash);
     assert_eq!(pre_block.number(), tip.block_number.value());
 
     // test get_cells rpc
@@ -1107,9 +1107,9 @@ async fn rpc() {
         .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1).pack())
+                .type_(Some(type_script1).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -1172,27 +1172,27 @@ async fn script_search_mode_rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).pack())
+        .args(Bytes::from(b"lock_script1".to_vec()).into())
         .build();
 
     let lock_script11 = ScriptBuilder::default()
         .code_hash(lock_script1.code_hash())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script11".to_vec()).pack())
+        .args(Bytes::from(b"lock_script11".to_vec()).into())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).pack())
+        .args(Bytes::from(b"type_script1".to_vec()).into())
         .build();
 
     let type_script11 = ScriptBuilder::default()
         .code_hash(type_script1.code_hash())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script11".to_vec()).pack())
+        .args(Bytes::from(b"type_script11".to_vec()).into())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -1200,7 +1200,7 @@ async fn script_search_mode_rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -1210,9 +1210,9 @@ async fn script_search_mode_rpc() {
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).pack())
+                .type_(Some(type_script1.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -1221,9 +1221,9 @@ async fn script_search_mode_rpc() {
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script11.clone())
-                .type_(Some(type_script11.clone()).pack())
+                .type_(Some(type_script11.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -1233,7 +1233,7 @@ async fn script_search_mode_rpc() {
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.pack()).build())
+        .header(HeaderBuilder::default().number(0.into()).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
@@ -1246,20 +1246,20 @@ async fn script_search_mode_rpc() {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Bytes::from(i.to_string()).pack())
+            .output_data(Bytes::from(i.to_string()).into())
             .build();
 
         pre_tx0 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).pack())
+                    .capacity(capacity_bytes!(1000).into())
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).pack())
+                    .type_(Some(type_script1.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1269,9 +1269,9 @@ async fn script_search_mode_rpc() {
             .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).pack())
+                    .capacity(capacity_bytes!(2000).into())
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11.clone()).pack())
+                    .type_(Some(type_script11.clone()).into())
                     .build(),
             )
             .output_data(Default::default())
@@ -1283,7 +1283,7 @@ async fn script_search_mode_rpc() {
             .transaction(pre_tx1.clone())
             .header(
                 HeaderBuilder::default()
-                    .number((pre_block.number() + 1).pack())
+                    .number((pre_block.number() + 1).into())
                     .parent_hash(pre_block.hash())
                     .epoch(
                         EpochNumberWithFraction::new(
@@ -1291,7 +1291,7 @@ async fn script_search_mode_rpc() {
                             pre_block.number(),
                             1000,
                         )
-                        .pack(),
+                        .into(),
                     )
                     .build(),
             )
@@ -1421,27 +1421,27 @@ async fn output_data_filter_mode_rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).pack())
+        .args(Bytes::from(b"lock_script1".to_vec()).into())
         .build();
 
     let lock_script11 = ScriptBuilder::default()
         .code_hash(lock_script1.code_hash())
         .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script11".to_vec()).pack())
+        .args(Bytes::from(b"lock_script11".to_vec()).into())
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).pack())
+        .code_hash(H256(rand::random()).into())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).pack())
+        .args(Bytes::from(b"type_script1".to_vec()).into())
         .build();
 
     let type_script11 = ScriptBuilder::default()
         .code_hash(type_script1.code_hash())
         .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script11".to_vec()).pack())
+        .args(Bytes::from(b"type_script11".to_vec()).into())
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -1449,7 +1449,7 @@ async fn output_data_filter_mode_rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
                 .build(),
         )
@@ -1459,9 +1459,9 @@ async fn output_data_filter_mode_rpc() {
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000).into())
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).pack())
+                .type_(Some(type_script1.clone()).into())
                 .build(),
         )
         .output_data(Default::default())
@@ -1470,19 +1470,19 @@ async fn output_data_filter_mode_rpc() {
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).pack())
+                .capacity(capacity_bytes!(2000).into())
                 .lock(lock_script11.clone())
-                .type_(Some(type_script11.clone()).pack())
+                .type_(Some(type_script11.clone()).into())
                 .build(),
         )
-        .output_data(hex::decode("62e907b15cbf00aa00bbcc").unwrap().pack())
+        .output_data(hex::decode("62e907b15cbf00aa00bbcc").unwrap().into())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.pack()).build())
+        .header(HeaderBuilder::default().number(0.into()).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 7669089979..b9808007d2 100644
--- a/util/test-chain-utils/src/chain.rs
+++ b/util/test-chain-utils/src/chain.rs
@@ -28,7 +28,7 @@ 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().pack())
+        .capacity(Capacity::bytes(data.len()).unwrap().into())
         .build();
 
     let script = Script::new_builder()
@@ -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.pack())
+        .output_data(always_success_cell_data.into())
         .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.pack())
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).pack())
+        .timestamp(GENESIS_TIMESTAMP.into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
         .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.pack())
+            .capacity(reward.into())
             .lock(always_success_script.to_owned())
             .build();
 
-        builder.output(output).output_data(data.pack()).build()
+        builder.output(output).output_data(data.into()).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()
-        .unpack()
+        .into()
 }
 
 /// 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 fe90aaee07..55674c4179 100644
--- a/util/test-chain-utils/src/median_time.rs
+++ b/util/test-chain-utils/src/median_time.rs
@@ -2,7 +2,6 @@ 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;
@@ -49,15 +48,15 @@ impl MockMedianTime {
                     .map(|(idx, timestamp)| {
                         let number = idx as BlockNumber;
                         let header = HeaderBuilder::default()
-                            .timestamp(timestamp.pack())
-                            .number(number.pack())
+                            .timestamp(timestamp.into())
+                            .number(number.into())
                             .epoch(
                                 EpochNumberWithFraction::new(
                                     number % MOCK_EPOCH_LENGTH,
                                     number / MOCK_EPOCH_LENGTH,
                                     MOCK_EPOCH_LENGTH,
                                 )
-                                .pack(),
+                                .into(),
                             )
                             .parent_hash(parent_hash.clone())
                             .build();
diff --git a/util/test-chain-utils/src/mock_chain.rs b/util/test-chain-utils/src/mock_chain.rs
index 059d3b3729..bafd472491 100644
--- a/util/test-chain-utils/src/mock_chain.rs
+++ b/util/test-chain-utils/src/mock_chain.rs
@@ -6,7 +6,6 @@ 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};
 
@@ -50,9 +49,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .compact_target(epoch.compact_target().pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .number((parent.number() + 1).into())
+            .compact_target(epoch.compact_target().into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
             .dao(dao)
             .transaction(cellbase)
             .proposals(txs.iter().map(TransactionView::proposal_short_id))
@@ -79,9 +78,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-            .compact_target(difficulty_to_compact(U256::from(difficulty)).pack())
+            .number((parent.number() + 1).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .compact_target(difficulty_to_compact(U256::from(difficulty)).into())
             .dao(dao)
             .transaction(cellbase)
             .proposals(ids)
@@ -103,9 +102,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-            .compact_target(difficulty_to_compact(U256::from(difficulty)).pack())
+            .number((parent.number() + 1).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .compact_target(difficulty_to_compact(U256::from(difficulty)).into())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -127,9 +126,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .compact_target(difficulty_to_compact(difficulty + U256::from(inc)).pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .number((parent.number() + 1).into())
+            .compact_target(difficulty_to_compact(difficulty + U256::from(inc)).into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -150,10 +149,10 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .compact_target(epoch.compact_target().pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
-            .nonce(nonce.pack())
+            .number((parent.number() + 1).into())
+            .compact_target(epoch.compact_target().into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .nonce(nonce.into())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -174,9 +173,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .compact_target(epoch.compact_target().pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .number((parent.number() + 1).into())
+            .compact_target(epoch.compact_target().into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -210,9 +209,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).pack())
-            .compact_target(epoch.compact_target().pack())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).pack())
+            .number((parent.number() + 1).into())
+            .compact_target(epoch.compact_target().into())
+            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
             .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 1686f7b453..53e44a3f40 100644
--- a/util/test-chain-utils/src/mock_store.rs
+++ b/util/test-chain-utils/src/mock_store.rs
@@ -9,7 +9,6 @@ use ckb_types::{
         BlockExt, BlockView, EpochExt, HeaderView,
     },
     packed::{Byte32, OutPoint},
-    prelude::*,
 };
 use std::sync::Arc;
 use tempfile::TempDir;
@@ -119,14 +118,14 @@ impl CellProvider for MockStore {
         match self.store().get_transaction(&out_point.tx_hash()) {
             Some((tx, _)) => tx
                 .outputs()
-                .get(out_point.index().unpack())
+                .get(out_point.index().into())
                 .map(|cell| {
                     let data = tx
                         .outputs_data()
-                        .get(out_point.index().unpack())
+                        .get(out_point.index().into())
                         .expect("output data");
 
-                    let cell_meta = CellMetaBuilder::from_cell_output(cell, data.unpack())
+                    let cell_meta = CellMetaBuilder::from_cell_output(cell, data.into())
                         .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 2b55b03c07..fb0fb3b077 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.pack())
+        .output_data(always_success_cell_data.into())
         .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.pack())
+        .output_data(load_input_data_hash_cell_data.into())
         .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.pack())
+        .output_data(load_input_one_byte_cell_data.into())
         .build()
 }
 
@@ -97,11 +97,11 @@ pub fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity.pack())
+                    .capacity(capacity.into())
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().pack())
+            .output_data(Bytes::new().into())
             .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().unpack();
+            let capacity: Capacity = parent_outputs.get(*i).unwrap().capacity().into();
             capacity
         })
         .try_fold(Capacity::zero(), Capacity::safe_add)
@@ -139,13 +139,13 @@ pub fn create_multi_outputs_transaction(
             output_capacity
         };
         CellOutputBuilder::default()
-            .capacity(capacity.pack())
+            .capacity(capacity.into())
             .lock(always_success_script.clone())
             .build()
     });
 
     let outputs_data = (0..output_len)
-        .map(|_| data.pack())
+        .map(|_| (&data).into())
         .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).pack())
+                .capacity(capacity_bytes!(100).into())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(data.pack())
+        .output_data(data.into())
         .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 65b1e0cc72..846e86ee73 100644
--- a/util/types/src/conversion/blockchain.rs
+++ b/util/types/src/conversion/blockchain.rs
@@ -6,9 +6,28 @@ 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 fc7374d02b..d238a7cfa4 100644
--- a/util/types/src/conversion/storage.rs
+++ b/util/types/src/conversion/storage.rs
@@ -9,6 +9,21 @@ 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 {
@@ -19,6 +34,16 @@ 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()
@@ -28,6 +53,21 @@ 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 {
@@ -38,6 +78,16 @@ 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()
@@ -48,6 +98,22 @@ 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 {
@@ -59,6 +125,17 @@ 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 {
@@ -74,6 +151,21 @@ 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()
@@ -88,6 +180,26 @@ 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.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.pack())
+            .txs_sizes((&value.txs_sizes).into())
+            .build()
+    }
+}
+
 impl<'r> Unpack<core::BlockExt> for packed::BlockExtV1Reader<'r> {
     fn unpack(&self) -> core::BlockExt {
         core::BlockExt {
@@ -103,6 +215,21 @@ 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()
@@ -118,6 +245,27 @@ impl Pack<packed::EpochExt> for core::EpochExt {
     }
 }
 
+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().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())
+            .start_number(value.start_number().into())
+            .length(value.length().into())
+            .compact_target(value.compact_target().into())
+            .build()
+    }
+}
+
 impl<'r> Unpack<core::EpochExt> for packed::EpochExtReader<'r> {
     fn unpack(&self) -> core::EpochExt {
         core::EpochExt {
@@ -134,6 +282,24 @@ 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()
@@ -148,6 +314,26 @@ impl Pack<packed::TransactionInfo> for core::TransactionInfo {
     }
 }
 
+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.into())
+            .build();
+        packed::TransactionInfo::new_builder()
+            .key(key)
+            .block_number(value.block_number.into())
+            .block_epoch(value.block_epoch.into())
+            .build()
+    }
+}
+
 impl<'r> Unpack<core::TransactionInfo> for packed::TransactionInfoReader<'r> {
     fn unpack(&self) -> core::TransactionInfo {
         core::TransactionInfo {
@@ -159,3 +345,15 @@ 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 0fbdc5bd98..3880e583fa 100644
--- a/util/types/src/conversion/utilities.rs
+++ b/util/types/src/conversion/utilities.rs
@@ -7,3 +7,19 @@ 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/verification/contextual/src/contextual_block_verifier.rs b/verification/contextual/src/contextual_block_verifier.rs
index 74bd483a47..cb701abfdf 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.pack())
+            .capacity(block_reward.total.into())
             .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 fc6c4182d4..a8914bbf7f 100644
--- a/verification/contextual/src/tests/contextual_block_verifier.rs
+++ b/verification/contextual/src/tests/contextual_block_verifier.rs
@@ -13,7 +13,9 @@ use ckb_types::{
         EpochExt, EpochNumberWithFraction, HeaderBuilder, HeaderView, TransactionBuilder,
         TransactionView, UncleBlockView,
     },
-    packed::{Byte32, CellDep, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script},
+    packed::{
+        self, Byte32, CellDep, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script,
+    },
     prelude::*,
     utilities::DIFF_TWO,
 };
@@ -34,11 +36,11 @@ fn gen_block(
     let cellbase = create_cellbase(number);
     let header = HeaderBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(now.pack())
-        .number(number.pack())
-        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
-        .compact_target(compact_target.pack())
-        .nonce(nonce.pack())
+        .timestamp(now.into())
+        .number(number.into())
+        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
+        .compact_target(compact_target.into())
+        .nonce(nonce.into())
         .build();
 
     BlockBuilder::default()
@@ -57,9 +59,9 @@ fn create_transaction(
 ) -> TransactionView {
     let capacity = 100_000_000 / 100_usize;
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(capacity).unwrap().pack())
+        .capacity(Capacity::bytes(capacity).unwrap().into())
         .lock(always_success_script.to_owned())
-        .type_(Some(always_success_script.to_owned()).pack())
+        .type_(Some(always_success_script.to_owned()).into())
         .build();
     let inputs: Vec<CellInput> = (0..100)
         .map(|index| CellInput::new(OutPoint::new(parent.clone(), index), 0))
@@ -69,9 +71,11 @@ fn create_transaction(
         .build();
 
     TransactionBuilder::default()
-        .inputs(inputs.pack())
-        .outputs(vec![output; 100].pack())
-        .outputs_data(vec![Bytes::new(); 100].pack())
+        .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(),
+        ))
         .cell_dep(cell_dep)
         .build()
 }
@@ -95,7 +99,7 @@ fn create_cellbase(number: BlockNumber) -> TransactionView {
     TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(number))
         .output(CellOutputBuilder::default().build())
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build()
 }
 
@@ -108,14 +112,14 @@ fn setup_env() -> (ChainController, Shared, Byte32, Script, OutPoint) {
         .output(always_success_cell.clone())
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1_000_000).pack())
+                .capacity(capacity_bytes!(1_000_000).into())
                 .lock(always_success_script.clone())
-                .type_(Some(always_success_script.clone()).pack())
+                .type_(Some(always_success_script.clone()).into())
                 .build();
             100
         ])
-        .output_data(always_success_cell_data.to_owned().pack())
-        .outputs_data(vec![Bytes::new().pack(); 100])
+        .output_data(always_success_cell_data.to_owned().into())
+        .outputs_data(vec![Bytes::new().into(); 100])
         .build();
     let tx_hash = tx.data().calc_tx_hash();
     let genesis_block = BlockBuilder::default().transaction(tx).build();
@@ -160,7 +164,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.pack()).build();
+    let block = BlockBuilder::default().epoch(actual_epoch.into()).build();
     let mut epoch = EpochExt::default();
     epoch.set_length(1);
 
@@ -180,8 +184,8 @@ fn test_epoch_difficulty() {
     epoch.set_length(1);
 
     let block = BlockBuilder::default()
-        .epoch(epoch.number_with_fraction(0).pack())
-        .compact_target(0x200c_30c3u32.pack())
+        .epoch(epoch.number_with_fraction(0).into())
+        .compact_target(0x200c_30c3u32.into())
         .build();
 
     assert_error_eq!(
diff --git a/verification/contextual/src/tests/uncle_verifier.rs b/verification/contextual/src/tests/uncle_verifier.rs
index 0928abdee9..87494b6f43 100644
--- a/verification/contextual/src/tests/uncle_verifier.rs
+++ b/verification/contextual/src/tests/uncle_verifier.rs
@@ -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.pack())
-        .epoch(epoch.number_with_fraction(number).pack())
-        .number(number.pack())
-        .compact_target(epoch.compact_target().pack())
-        .nonce(nonce.pack())
+        .timestamp(now.into())
+        .epoch(epoch.number_with_fraction(number).into())
+        .number(number.into())
+        .compact_target(epoch.compact_target().into())
+        .nonce(nonce.into())
         .build()
 }
 
@@ -169,7 +169,7 @@ fn test_invalid_target() {
     let uncle = chain2[16]
         .clone()
         .as_advanced_builder()
-        .compact_target(invalid_target.pack())
+        .compact_target(invalid_target.into())
         .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().pack())
+        .compact_target(chain1[block_number].compact_target().into())
         .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].pack())
+        .proposal([1; 10].into())
         .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].pack())
+        .proposal([1; 10].into())
         .build()
         .as_uncle();
     let block = chain1[8]
diff --git a/verification/src/tests/block_verifier.rs b/verification/src/tests/block_verifier.rs
index e2638882ef..73bd870ae2 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).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -35,10 +35,10 @@ fn create_cellbase_transaction_with_capacity(capacity: Capacity) -> TransactionV
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity.pack())
+                .capacity(capacity.into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -48,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).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
-        .output_data(Bytes::from("123").pack())
+        .output_data(Bytes::from("123").into())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -61,15 +61,15 @@ fn create_cellbase_transaction_with_two_output() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -79,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).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
+        .output_data(Bytes::new().into())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -94,13 +94,13 @@ fn create_cellbase_transaction() -> TransactionView {
 
 fn create_normal_transaction() -> TransactionView {
     TransactionBuilder::default()
-        .input(CellInput::new(OutPoint::new(h256!("0x1").pack(), 0), 0))
+        .input(CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .build()
 }
 
@@ -195,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().pack())
+        .output_data(Bytes::new().into())
         .build();
     let block = BlockBuilder::new_with_number(2)
         .transaction(cellbase_without_output)
@@ -209,7 +209,7 @@ pub fn test_cellbase_without_output() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         )
         .build();
@@ -293,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").pack())
+        .proposals_hash(h256!("0x1").into())
         .build();
     let block = BlockBuilder::default()
         .header(header)
diff --git a/verification/src/tests/genesis_verifier.rs b/verification/src/tests/genesis_verifier.rs
index 716ef144c4..c31899f1cb 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, prelude::*};
+use ckb_types::core::EpochNumberWithFraction;
 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.pack())
-        .epoch(EpochNumberWithFraction::from_full_value(0).pack())
+        .number(42.into())
+        .epoch(EpochNumberWithFraction::from_full_value(0).into())
         .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].pack())
+        .parent_hash([42u8; 32].into())
         .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].pack()
+            parent_hash: [42u8; 32].into()
         },
     );
 }
diff --git a/verification/src/tests/header_verifier.rs b/verification/src/tests/header_verifier.rs
index 8fe6abbbaa..716db7fe68 100644
--- a/verification/src/tests/header_verifier.rs
+++ b/verification/src/tests/header_verifier.rs
@@ -15,7 +15,6 @@ use ckb_types::{
         EpochNumberWithFraction, HeaderBuilder,
     },
     packed::Header,
-    prelude::*,
 };
 
 use super::BuilderBaseOnBlockNumber;
@@ -41,7 +40,7 @@ pub fn test_version() {
         .build();
 
     let header = HeaderBuilder::default()
-        .version((consensus.block_version() + 1).pack())
+        .version((consensus.block_version() + 1).into())
         .build();
     let verifier = VersionVerifier::new(&header, &consensus);
 
@@ -54,8 +53,8 @@ pub fn test_version() {
     );
     let epoch = EpochNumberWithFraction::new(10, 40, 1000);
     let header = HeaderBuilder::default()
-        .version((consensus.block_version() + 1).pack())
-        .epoch(epoch.pack())
+        .version((consensus.block_version() + 1).into())
+        .epoch(epoch.into())
         .build();
     let verifier = VersionVerifier::new(&header, &consensus);
     assert!(verifier.verify().is_ok());
@@ -70,7 +69,7 @@ fn test_timestamp() {
     let timestamp = unix_time_as_millis() + 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp.pack())
+        .timestamp(timestamp.into())
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -92,7 +91,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.pack())
+        .timestamp(timestamp.into())
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -120,7 +119,7 @@ fn test_timestamp_too_new() {
     let timestamp = max + 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp.pack())
+        .timestamp(timestamp.into())
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -163,7 +162,7 @@ fn test_epoch() {
 
         for epoch_malformed in epochs_malformed {
             let malformed = HeaderBuilder::default()
-                .epoch(epoch_malformed.pack())
+                .epoch(epoch_malformed.into())
                 .build();
             let result = EpochVerifier::new(parent, &malformed).verify();
             assert!(result.is_err(), "input: {epoch_malformed:#}");
@@ -208,7 +207,7 @@ fn test_epoch() {
         ];
 
         for (parent, epoch_current) in epochs {
-            let current = HeaderBuilder::default().epoch(epoch_current.pack()).build();
+            let current = HeaderBuilder::default().epoch(epoch_current.into()).build();
 
             let result = EpochVerifier::new(parent, &current).verify();
             assert!(result.is_err(), "current: {current:#}, parent: {parent:#}");
@@ -237,7 +236,7 @@ fn test_epoch() {
             ),
         ];
         for (parent, epoch_current) in epochs {
-            let current = HeaderBuilder::default().epoch(epoch_current.pack()).build();
+            let current = HeaderBuilder::default().epoch(epoch_current.into()).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 9f1eab8a67..74466a23d2 100644
--- a/verification/src/tests/mod.rs
+++ b/verification/src/tests/mod.rs
@@ -5,10 +5,7 @@ mod genesis_verifier;
 mod header_verifier;
 mod transaction_verifier;
 
-use ckb_types::{
-    core::{BlockBuilder, BlockNumber, EpochNumberWithFraction, HeaderBuilder},
-    prelude::*,
-};
+use ckb_types::core::{BlockBuilder, BlockNumber, EpochNumberWithFraction, HeaderBuilder};
 
 trait BuilderBaseOnBlockNumber {
     fn new_with_number(number: BlockNumber) -> Self;
@@ -17,15 +14,15 @@ trait BuilderBaseOnBlockNumber {
 impl BuilderBaseOnBlockNumber for HeaderBuilder {
     fn new_with_number(number: BlockNumber) -> HeaderBuilder {
         Self::default()
-            .number(number.pack())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
+            .number(number.into())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
     }
 }
 
 impl BuilderBaseOnBlockNumber for BlockBuilder {
     fn new_with_number(number: BlockNumber) -> BlockBuilder {
         Self::default()
-            .number(number.pack())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
+            .number(number.into())
+            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
     }
 }
diff --git a/verification/src/tests/transaction_verifier.rs b/verification/src/tests/transaction_verifier.rs
index 16f05fe1fe..521d4d0bae 100644
--- a/verification/src/tests/transaction_verifier.rs
+++ b/verification/src/tests/transaction_verifier.rs
@@ -44,7 +44,7 @@ pub fn test_empty() {
 #[test]
 pub fn test_version() {
     let transaction = TransactionBuilder::default()
-        .version((TX_VERSION + 1).pack())
+        .version((TX_VERSION + 1).into())
         .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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
         )
-        .output_data(data.pack())
+        .output_data(data.into())
         .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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
         )
-        .output_data(data.pack())
+        .output_data(data.into())
         .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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .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).pack())
-                .type_(Some(dao_type_script.clone()).pack())
+                .capacity(capacity_bytes!(500).into())
+                .type_(Some(dao_type_script.clone()).into())
                 .build(),
         )
-        .output_data(Bytes::new().pack())
+        .output_data(Bytes::new().into())
         .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).pack())
+        .capacity(capacity_bytes!(50).into())
         .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).pack())
+        .capacity(capacity_bytes!(50).into())
         .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).pack())
+        .capacity(capacity_bytes!(50).into())
         .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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(100).pack())
+                .capacity(capacity_bytes!(100).into())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().pack(); 2])
+        .outputs_data(vec![Bytes::new().into(); 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).pack())
+                    .capacity(capacity_bytes!(49).into())
                     .build(),
                 Bytes::new(),
             )
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(100).pack())
+                    .capacity(capacity_bytes!(100).into())
                     .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").pack(), 0);
+    let out_point = OutPoint::new(h256!("0x1").into(), 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").pack(), h256!("0x1").pack()])
+        .header_deps(vec![h256!("0x1").into(), h256!("0x1").into()])
         .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").pack()
+            hash: h256!("0x1").into()
         },
     );
 }
@@ -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.pack())
-            .epoch(epoch.pack())
+            .number(block_number.into())
+            .epoch(epoch.into())
             .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").pack(), 0),
+            OutPoint::new(h256!("0x1").into(), 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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .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.pack())
-            .epoch(epoch.pack())
+            .number(block_number.into())
+            .epoch(epoch.into())
             .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.pack())
-            .epoch(epoch.pack())
+            .number(block_number.into())
+            .epoch(epoch.into())
             .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.pack())
-            .epoch(epoch.pack())
+            .number(block_number.into())
+            .epoch(epoch.into())
             .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").pack(), 0), 0x0000_0000_0000_000a),
+            CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0x0000_0000_0000_000a),
             // relative lock until after 2 blocks
-            CellInput::new(OutPoint::new(h256!("0x1").pack(), 0), 0xc000_0000_0000_0002),
+            CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0xc000_0000_0000_0002),
         ])
         .build();
     // spent after 1024 seconds and 4 blocks (less than 10 blocks)
@@ -825,19 +825,19 @@ fn test_dao_disables_different_lock_script_size() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).pack())
+                .capacity(capacity_bytes!(200).into())
                 .lock(
                     Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).pack())
+                        .args(Bytes::from(vec![1; 20]).into())
                         .build(),
                 )
-                .type_(Some(dao_type_script.clone()).pack())
+                .type_(Some(dao_type_script.clone()).into())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().pack(); 2])
+        .outputs_data(vec![Bytes::new().into(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -846,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).pack())
+                    .capacity(capacity_bytes!(50).into())
                     .build(),
                 Bytes::new(),
             )
@@ -858,9 +858,9 @@ fn test_dao_disables_different_lock_script_size() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201).pack())
-                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
-                    .type_(Some(dao_type_script).pack())
+                    .capacity(capacity_bytes!(201).into())
+                    .lock(Script::new_builder().args(Bytes::new().into()).build())
+                    .type_(Some(dao_type_script).into())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -888,19 +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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).pack())
+                .capacity(capacity_bytes!(200).into())
                 .lock(
                     Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).pack())
+                        .args(Bytes::from(vec![1; 20]).into())
                         .build(),
                 )
-                .type_(Some(dao_type_script.clone()).pack())
+                .type_(Some(dao_type_script.clone()).into())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().pack(); 2])
+        .outputs_data(vec![Bytes::new().into(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -909,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).pack())
+                    .capacity(capacity_bytes!(50).into())
                     .build(),
                 Bytes::new(),
             )
@@ -921,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).pack())
-                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
-                    .type_(Some(dao_type_script).pack())
+                    .capacity(capacity_bytes!(201).into())
+                    .lock(Script::new_builder().args(Bytes::new().into()).build())
+                    .type_(Some(dao_type_script).into())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -948,18 +948,18 @@ fn test_non_dao_allows_lock_script_size() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).pack())
+                .capacity(capacity_bytes!(200).into())
                 .lock(
                     Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).pack())
+                        .args(Bytes::from(vec![1; 20]).into())
                         .build(),
                 )
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().pack(); 2])
+        .outputs_data(vec![Bytes::new().into(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -968,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).pack())
+                    .capacity(capacity_bytes!(50).into())
                     .build(),
                 Bytes::new(),
             )
@@ -980,8 +980,8 @@ fn test_non_dao_allows_lock_script_size() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201).pack())
-                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
+                    .capacity(capacity_bytes!(201).into())
+                    .lock(Script::new_builder().args(Bytes::new().into()).build())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -1006,19 +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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).pack())
+                .capacity(capacity_bytes!(200).into())
                 .lock(
                     Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).pack())
+                        .args(Bytes::from(vec![1; 20]).into())
                         .build(),
                 )
-                .type_(Some(dao_type_script.clone()).pack())
+                .type_(Some(dao_type_script.clone()).into())
                 .build(),
         ])
-        .outputs_data(vec![Bytes::new().pack(); 2])
+        .outputs_data(vec![Bytes::new().into(); 2])
         .build();
 
     let rtx = Arc::new(ResolvedTransaction {
@@ -1027,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).pack())
+                    .capacity(capacity_bytes!(50).into())
                     .build(),
                 Bytes::new(),
             )
@@ -1039,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).pack())
-                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
-                    .type_(Some(dao_type_script).pack())
+                    .capacity(capacity_bytes!(201).into())
+                    .lock(Script::new_builder().args(Bytes::new().into()).build())
+                    .type_(Some(dao_type_script).into())
                     .build(),
                 Bytes::from(vec![1; 8]),
             )
@@ -1066,16 +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).pack())
+                .capacity(capacity_bytes!(50).into())
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).pack())
+                .capacity(capacity_bytes!(200).into())
                 .lock(
                     Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).pack())
+                        .args(Bytes::from(vec![1; 20]).into())
                         .build(),
                 )
-                .type_(Some(dao_type_script).pack())
+                .type_(Some(dao_type_script).into())
                 .build(),
         ])
         .outputs_data(vec![])
@@ -1087,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).pack())
+                    .capacity(capacity_bytes!(50).into())
                     .build(),
                 Bytes::new(),
             )
@@ -1099,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).pack())
-                    .lock(Script::new_builder().args(Bytes::new().pack()).build())
+                    .capacity(capacity_bytes!(201).into())
+                    .lock(Script::new_builder().args(Bytes::new().into()).build())
                     .build(),
                 Bytes::from(vec![1; 8]),
             )
diff --git a/verification/src/transaction_verifier.rs b/verification/src/transaction_verifier.rs
index b6317cebaa..ff044346aa 100644
--- a/verification/src/transaction_verifier.rs
+++ b/verification/src/transaction_verifier.rs
@@ -15,7 +15,6 @@ use ckb_types::{
         Capacity, Cycle, EpochNumberWithFraction, ScriptHashType, TransactionView, Version,
     },
     packed::{Byte32, CellOutput},
-    prelude::*,
 };
 use std::collections::HashSet;
 use std::sync::Arc;
@@ -507,7 +506,7 @@ impl CapacityVerifier {
                 return Err((TransactionError::InsufficientCellCapacity {
                     index,
                     inner: TransactionErrorSource::Outputs,
-                    capacity: output.capacity().unpack(),
+                    capacity: output.capacity().into(),
                     occupied_capacity: output.occupied_capacity(data_occupied_capacity)?,
                 })
                 .into());
@@ -738,7 +737,7 @@ impl<DL: HeaderFieldsProvider> SinceVerifier<DL> {
             .enumerate()
         {
             // ignore empty since
-            let since: u64 = input.since().unpack();
+            let since: u64 = input.since().into();
             if since == 0 {
                 continue;
             }

From 602fdc846dda2fe23e6e4484905382cb6ffeff4d Mon Sep 17 00:00:00 2001
From: driftluo <driftluo@foxmail.com>
Date: Fri, 12 Jul 2024 14:04:08 +0800
Subject: [PATCH 3/3] feat: change builder funtion to generics

---
 Cargo.lock                                    |    1 -
 benches/benches/benchmarks/overall.rs         |   10 +-
 benches/benches/benchmarks/resolve.rs         |   13 +-
 benches/benches/benchmarks/util.rs            |   66 +-
 chain/src/init_load_unverified.rs             |    4 +-
 chain/src/lib.rs                              |    9 +-
 chain/src/tests/basic.rs                      |   38 +-
 chain/src/tests/block_assembler.rs            |   20 +-
 chain/src/tests/cell.rs                       |   26 +-
 chain/src/tests/delay_verify.rs               |   60 +-
 chain/src/tests/dep_cell.rs                   |   50 +-
 chain/src/tests/find_fork.rs                  |   40 +-
 chain/src/tests/load_code_with_snapshot.rs    |   32 +-
 chain/src/tests/load_input_cell_data.rs       |   10 +-
 chain/src/tests/load_input_data_hash_cell.rs  |   10 +-
 .../tests/non_contextual_block_txs_verify.rs  |   22 +-
 chain/src/tests/orphan_block_pool.rs          |   21 +-
 chain/src/tests/reward.rs                     |   26 +-
 chain/src/tests/util.rs                       |    6 +-
 chain/src/verify.rs                           |    4 +-
 devtools/ci/ci_main.sh                        |    2 +-
 miner/src/miner.rs                            |    5 +-
 network/src/protocols/discovery/protocol.rs   |   10 +-
 network/src/protocols/identify/mod.rs         |    6 +-
 network/src/protocols/ping.rs                 |   16 +-
 rpc/src/module/miner.rs                       |    2 +-
 rpc/src/module/net.rs                         |   10 +-
 rpc/src/module/test.rs                        |    2 +-
 rpc/src/tests/examples.rs                     |    6 +-
 rpc/src/tests/mod.rs                          |   10 +-
 rpc/src/tests/module/miner.rs                 |    8 +-
 rpc/src/tests/module/pool.rs                  |   17 +-
 rpc/src/tests/setup.rs                        |   20 +-
 script/fuzz/fuzz_targets/syscall_spawn.rs     |   18 +-
 script/src/syscalls/tests/utils.rs            |    2 +-
 .../syscalls/tests/vm_latest/syscalls_1.rs    |   65 +-
 .../syscalls/tests/vm_latest/syscalls_2.rs    |    2 +-
 script/src/verify.rs                          |    4 +-
 .../tests/ckb_latest/features_since_v2019.rs  |  205 ++-
 .../tests/ckb_latest/features_since_v2021.rs  |  156 +-
 .../tests/ckb_latest/features_since_v2023.rs  |  471 +-----
 script/src/verify/tests/utils.rs              |   60 +-
 shared/src/shared.rs                          |    4 +-
 shared/src/shared_builder.rs                  |    3 +-
 spec/src/consensus.rs                         |    8 +-
 spec/src/lib.rs                               |   44 +-
 spec/src/tests/consensus.rs                   |    4 +-
 spec/src/tests/versionbits.rs                 |   16 +-
 store/src/cell.rs                             |   24 +-
 store/src/tests/db.rs                         |    7 +-
 store/src/transaction.rs                      |   10 +-
 store/src/write_batch.rs                      |    4 +-
 .../get_block_filter_check_points_process.rs  |    4 +-
 .../filter/get_block_filter_hashes_process.rs |    4 +-
 sync/src/filter/get_block_filters_process.rs  |    6 +-
 sync/src/net_time_checker.rs                  |    2 +-
 .../src/relayer/block_transactions_process.rs |    4 +-
 sync/src/relayer/compact_block_process.rs     |    4 +-
 .../src/relayer/get_block_proposal_process.rs |    2 +-
 .../relayer/get_block_transactions_process.rs |    6 +-
 sync/src/relayer/get_transactions_process.rs  |    2 +-
 sync/src/relayer/mod.rs                       |   20 +-
 .../relayer/tests/block_proposal_process.rs   |   12 +-
 .../tests/block_transactions_process.rs       |   64 +-
 .../tests/block_transactions_verifier.rs      |    4 +-
 sync/src/relayer/tests/compact_block.rs       |    8 +-
 .../relayer/tests/compact_block_process.rs    |   40 +-
 .../relayer/tests/compact_block_verifier.rs   |   20 +-
 .../tests/get_block_proposal_process.rs       |    2 +-
 .../relayer/tests/get_transactions_process.rs |    2 +-
 sync/src/relayer/tests/helper.rs              |   42 +-
 sync/src/relayer/tests/reconstruct_block.rs   |    8 +-
 sync/src/synchronizer/get_headers_process.rs  |    3 +-
 sync/src/synchronizer/mod.rs                  |    4 +-
 sync/src/tests/orphan_block_pool.rs           |  152 --
 sync/src/tests/sync_shared.rs                 |   12 +-
 sync/src/tests/synchronizer/basic_sync.rs     |   18 +-
 sync/src/tests/synchronizer/functions.rs      |   36 +-
 sync/src/tests/types.rs                       |   11 +-
 sync/src/tests/util.rs                        |    8 +-
 sync/src/types/mod.rs                         |    2 +-
 test/src/node.rs                              |   21 +-
 test/src/specs/alert/alert_propagation.rs     |   16 +-
 .../specs/consensus/insufficient_reward.rs    |    5 +-
 test/src/specs/dao/dao_tx.rs                  |    5 +-
 test/src/specs/dao/dao_user.rs                |   18 +-
 test/src/specs/dao/satoshi_dao_occupied.rs    |   11 +-
 test/src/specs/hardfork/v2021/cell_deps.rs    |   42 +-
 .../specs/hardfork/v2021/vm_b_extension.rs    |   12 +-
 test/src/specs/hardfork/v2021/vm_version1.rs  |   20 +-
 test/src/specs/hardfork/v2023/vm_version2.rs  |   20 +-
 test/src/specs/mining/basic.rs                |    2 +-
 test/src/specs/mining/bootstrap.rs            |    6 +-
 test/src/specs/mining/fee.rs                  |   22 +-
 test/src/specs/mining/proposal.rs             |    2 +-
 test/src/specs/mining/uncle.rs                |   21 +-
 test/src/specs/relay/block_relay.rs           |    2 +-
 test/src/specs/relay/compact_block.rs         |    6 +-
 .../specs/relay/get_block_proposal_process.rs |    2 +-
 .../relay/get_block_transactions_process.rs   |   11 +-
 test/src/specs/relay/transaction_relay.rs     |    2 +-
 .../relay/transaction_relay_low_fee_rate.rs   |    7 +-
 test/src/specs/rpc/submit_block.rs            |   11 +-
 test/src/specs/sync/block_filter.rs           |    8 +-
 test/src/specs/sync/block_sync.rs             |   12 +-
 test/src/specs/sync/chain_forks.rs            |   12 +-
 test/src/specs/sync/invalid_locator_size.rs   |    2 +-
 test/src/specs/tx_pool/collision.rs           |    7 +-
 test/src/specs/tx_pool/dead_cell_deps.rs      |    6 +-
 .../tx_pool/different_txs_with_same_input.rs  |    2 +-
 test/src/specs/tx_pool/limit.rs               |    2 +-
 test/src/specs/tx_pool/orphan_tx.rs           |    6 +-
 test/src/specs/tx_pool/pool_reconcile.rs      |    2 +-
 test/src/specs/tx_pool/replace.rs             |   38 +-
 .../src/specs/tx_pool/send_defected_binary.rs |   14 +-
 .../src/specs/tx_pool/send_large_cycles_tx.rs |   22 +-
 .../src/specs/tx_pool/send_low_fee_rate_tx.rs |    4 +-
 .../specs/tx_pool/send_multisig_secp_tx.rs    |   19 +-
 test/src/specs/tx_pool/send_secp_tx.rs        |   40 +-
 test/src/txo.rs                               |   14 +-
 test/src/util/cell.rs                         |    2 +-
 test/src/util/transaction.rs                  |    8 +-
 test/src/utils.rs                             |   21 +-
 tx-pool/src/block_assembler/mod.rs            |   26 +-
 tx-pool/src/block_assembler/tests.rs          |   10 +-
 tx-pool/src/component/tests/chunk.rs          |    9 +-
 tx-pool/src/component/tests/proposed.rs       |   32 +-
 tx-pool/src/component/tests/score_key.rs      |   16 +-
 tx-pool/src/component/tests/util.rs           |    6 +-
 util/dao/src/tests.rs                         |   46 +-
 util/gen-types/src/extension/calc_hash.rs     |   10 +-
 util/gen-types/src/extension/capacity.rs      |    2 +-
 util/gen-types/src/extension/shortcut.rs      |    6 +-
 .../src/extension/tests/calc_hash.rs          |  114 +-
 .../gen-types/src/extension/tests/capacity.rs |    4 +-
 .../src/extension/tests/check_data.rs         |   30 +-
 .../src/extension/tests/rust_core_traits.rs   |   84 +-
 .../src/extension/tests/serialized_size.rs    |   38 +-
 util/gen-types/src/generated/blockchain.rs    | 1246 ++++++++++-----
 util/gen-types/src/generated/extensions.rs    | 1351 ++++++++++++-----
 util/gen-types/src/generated/protocols.rs     |  224 ++-
 util/indexer/src/indexer.rs                   |  556 ++++---
 util/indexer/src/service.rs                   |  192 ++-
 util/jsonrpc-types/src/alert.rs               |   17 +-
 util/jsonrpc-types/src/block_template.rs      |   33 +-
 util/jsonrpc-types/src/blockchain.rs          |   94 +-
 util/jsonrpc-types/src/tests/blockchain.rs    |   10 +-
 util/launcher/Cargo.toml                      |    1 -
 .../src/components/get_last_state_proof.rs    |    2 +-
 .../src/components/get_transactions_proof.rs  |    6 +-
 util/light-client-protocol-server/src/lib.rs  |    4 +-
 .../src/tests/components/get_blocks_proof.rs  |    2 +-
 .../tests/components/get_last_state_proof.rs  |    6 +-
 .../components/get_transactions_proof.rs      |    2 +-
 .../src/tests/prelude.rs                      |    2 +-
 .../src/tests/utils/chain.rs                  |   10 +-
 util/migrate/src/migrations/cell.rs           |   12 +-
 util/migrate/src/tests.rs                     |    2 +-
 .../src/tests/generate_alert_signature.rs     |   32 +-
 util/network-alert/src/tests/test_notifier.rs |   10 +-
 util/network-alert/src/tests/test_verifier.rs |    4 +-
 util/reward-calculator/src/tests.rs           |   48 +-
 util/rich-indexer/src/indexer/insert.rs       |   12 +-
 .../async_indexer_handle/get_cells.rs         |   22 +-
 util/rich-indexer/src/tests/insert.rs         |  138 +-
 util/rich-indexer/src/tests/query.rs          |  312 ++--
 util/test-chain-utils/src/chain.rs            |   14 +-
 util/test-chain-utils/src/median_time.rs      |   17 +-
 util/test-chain-utils/src/mock_chain.rs       |   44 +-
 util/test-chain-utils/src/mock_utils.rs       |   16 +-
 util/types/src/conversion/storage.rs          |   50 +-
 util/types/src/core/advanced_builders.rs      |   59 +-
 util/types/src/core/cell.rs                   |   24 +-
 util/types/src/core/extras.rs                 |    2 +-
 util/types/src/core/tests/cell.rs             |   48 +-
 util/types/src/core/tests/transaction_meta.rs |    3 +-
 util/types/src/core/tests/views.rs            |   10 +-
 util/types/src/core/views.rs                  |   31 +-
 util/types/src/extension.rs                   |   18 +-
 .../src/utilities/merkle_mountain_range.rs    |   34 +-
 util/types/src/utilities/merkle_tree.rs       |    2 +-
 .../src/contextual_block_verifier.rs          |    2 +-
 .../src/tests/contextual_block_verifier.rs    |   39 +-
 .../contextual/src/tests/uncle_verifier.rs    |   24 +-
 verification/src/tests/block_verifier.rs      |   38 +-
 verification/src/tests/genesis_verifier.rs    |    6 +-
 verification/src/tests/header_verifier.rs     |   20 +-
 verification/src/tests/mod.rs                 |   16 +-
 .../src/tests/transaction_verifier.rs         |  154 +-
 189 files changed, 4372 insertions(+), 3778 deletions(-)
 delete mode 100644 sync/src/tests/orphan_block_pool.rs

diff --git a/Cargo.lock b/Cargo.lock
index c3ac071e90..5d6ae80e11 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1033,7 +1033,6 @@ dependencies = [
  "ckb-store",
  "ckb-sync",
  "ckb-tx-pool",
- "ckb-types",
  "ckb-verification",
  "ckb-verification-traits",
 ]
diff --git a/benches/benches/benchmarks/overall.rs b/benches/benches/benchmarks/overall.rs
index 10c6876d3e..921bf85804 100644
--- a/benches/benches/benchmarks/overall.rs
+++ b/benches/benches/benchmarks/overall.rs
@@ -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).into())
+                .capacity(capacity_bytes!(50_000))
                 .lock(secp_script.clone())
                 .build();
             TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(output.clone())
                 .output(output)
-                .output_data(data.clone().into())
-                .output_data(data.into())
+                .output_data(&data)
+                .output_data(&data)
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .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>().into())
+                                .nonce(random::<u128>())
                                 .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 8fa587210c..a250781623 100644
--- a/benches/benches/benchmarks/resolve.rs
+++ b/benches/benches/benchmarks/resolve.rs
@@ -33,22 +33,19 @@ const DEFAULT_CODE_HASH: H256 =
 
 fn script() -> Script {
     Script::new_builder()
-        .code_hash(DEFAULT_CODE_HASH.into())
-        .args(Bytes::from(PUBKEY_HASH.as_bytes()).into())
-        .hash_type(ScriptHashType::Type.into())
+        .code_hash(DEFAULT_CODE_HASH)
+        .args(Bytes::from(PUBKEY_HASH.as_bytes()))
+        .hash_type(ScriptHashType::Type)
         .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.into())
-        .build();
+    let out_point = OutPoint::new_builder().tx_hash(tx_hash).index(0u32).build();
 
     CellDep::new_builder()
         .out_point(out_point)
-        .dep_type(DepType::DepGroup.into())
+        .dep_type(DepType::DepGroup)
         .build()
 }
 
diff --git a/benches/benches/benchmarks/util.rs b/benches/benches/benchmarks/util.rs
index ba93d6c2f2..9a5afc336d 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).into())
+                        .capacity(capacity_bytes!(50_000))
                         .lock(always_success_script.clone())
                         .build(),
                 )
-                .output_data(data.into())
+                .output_data(data)
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
         .dao(dao)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .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.into())
+        .output_data(always_success_cell_data)
         .build()
 }
 
@@ -110,11 +110,11 @@ pub fn create_always_success_cellbase(shared: &Shared, parent: &HeaderView) -> T
         builder
             .output(
                 CellOutput::new_builder()
-                    .capacity(capacity.into())
+                    .capacity(capacity)
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .build()
     }
 }
@@ -185,11 +185,11 @@ pub fn gen_always_success_block(
         .transactions(transactions)
         .proposals(proposals)
         .parent_hash(p_block.hash())
-        .number(number.into())
-        .timestamp(timestamp.into())
-        .compact_target(epoch.compact_target().into())
-        .epoch(epoch.number_with_fraction(number).into())
-        .nonce(random::<u128>().into())
+        .number(number)
+        .timestamp(timestamp)
+        .compact_target(epoch.compact_target())
+        .epoch(epoch.number_with_fraction(number))
+        .nonce(random::<u128>())
         .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().into())
+            .capacity(Capacity::bytes(data.len()).unwrap())
             .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().into())
+            .capacity(Capacity::bytes(data.len()).unwrap())
             .build();
 
         let script = Script::new_builder()
             .code_hash(CellOutput::calc_data_hash(&data))
-            .args(Bytes::from(PUBKEY_HASH.as_bytes()).into())
-            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(PUBKEY_HASH.as_bytes()))
+            .hash_type(ScriptHashType::Data)
             .build();
 
         (cell, data, script)
@@ -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).into())
+                .capacity(capacity_bytes!(50_000))
                 .lock(secp_script.clone())
                 .build();
             TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::null(), 0))
                 .output(output.clone())
                 .output(output)
-                .output_data((&data).into())
-                .output_data(data.into())
+                .output_data(&data)
+                .output_data(&data)
                 .build()
         })
         .collect();
 
     let genesis_block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .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.into())
+                    .capacity(capacity)
                     .lock(secp_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .build()
     }
 }
@@ -395,11 +395,11 @@ pub fn gen_secp_block(
         .transactions(transactions)
         .proposals(proposals)
         .parent_hash(p_block.hash())
-        .number(number.into())
-        .timestamp(timestamp.into())
-        .compact_target(epoch.compact_target().into())
-        .epoch(epoch.number_with_fraction(number).into())
-        .nonce(random::<u128>().into())
+        .number(number)
+        .timestamp(timestamp)
+        .compact_target(epoch.compact_target())
+        .epoch(epoch.number_with_fraction(number))
+        .nonce(random::<u128>())
         .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).into())
+                .capacity(capacity_bytes!(50_000))
                 .lock(lock)
                 .build(),
         )
-        .output_data(data.into())
+        .output_data(data)
         .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).into())
+        .capacity(capacity_bytes!(50_000))
         .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).into())
-        .output_data(data.into())
+        .output_data(&data)
+        .output_data(&data)
         .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])).into())
+        .lock(Some(Bytes::from(vec![0u8; 65])))
         .build();
     let witness_len: u64 = witness.as_bytes().len() as u64;
     let non_sig_witnesses = vec![Bytes::new(); inputs_count - 1];
@@ -470,7 +470,7 @@ pub fn create_2out_transaction(
         .expect("sign tx")
         .serialize()
         .into();
-    let witness = witness.as_builder().lock(Some(sig).into()).build();
+    let witness = witness.as_builder().lock(Some(sig)).build();
 
     let mut witnesses = vec![witness.as_bytes().into()];
     witnesses.extend(non_sig_witnesses.into_iter().map(|w| w.into()));
diff --git a/chain/src/init_load_unverified.rs b/chain/src/init_load_unverified.rs
index 30b0247cdb..11283fe17c 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, Pack, Reader};
+use ckb_types::prelude::{Entity, FromSliceShouldBeOk, 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.pack();
+        let pack_number: packed::Uint64 = check_unverified_number.into();
         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 34b61ef562..7d4cae3d55 100644
--- a/chain/src/lib.rs
+++ b/chain/src/lib.rs
@@ -28,7 +28,6 @@ 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;
 
@@ -89,11 +88,11 @@ impl From<LonelyBlock> for LonelyBlockHash {
             switch,
             verify_callback,
         } = val;
-        let block_hash_h256: H256 = block.hash().unpack();
+        let block_hash_h256: H256 = block.hash().into();
         let block_number: BlockNumber = block.number();
-        let parent_hash_h256: H256 = block.parent_hash().unpack();
-        let block_hash = block_hash_h256.pack();
-        let parent_hash = parent_hash_h256.pack();
+        let parent_hash_h256: H256 = block.parent_hash().into();
+        let block_hash = block_hash_h256.into();
+        let parent_hash = parent_hash_h256.into();
 
         let epoch_number: EpochNumber = block.epoch().number();
 
diff --git a/chain/src/tests/basic.rs b/chain/src/tests/basic.rs
index ae69ec9cfd..0b3a0fe886 100644
--- a/chain/src/tests/basic.rs
+++ b/chain/src/tests/basic.rs
@@ -65,11 +65,11 @@ fn process_genesis_block() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000).pack())
+                .capacity(capacity_bytes!(100_000_000))
                 .build();
             100
         ])
-        .outputs_data(vec![Bytes::new(); 100].pack())
+        .outputs_data(vec![packed::Bytes::default(); 100])
         .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)).pack())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .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)).pack())
+        .compact_target(difficulty_to_compact(U256::from(999u64)))
         .dao(dao)
         .build();
     let result = chain_controller.blocking_process_block(Arc::new(different_genesis_block));
@@ -119,7 +119,7 @@ fn test_genesis_transaction_spend() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000).into())
+                .capacity(capacity_bytes!(100_000_000))
                 .build();
             100
         ])
@@ -138,7 +138,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)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .dao(dao)
         .build();
 
@@ -431,7 +431,7 @@ fn test_genesis_transaction_fetch() {
         .input(CellInput::new(OutPoint::null(), 0))
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100_000_000).into())
+                .capacity(capacity_bytes!(100_000_000))
                 .lock(Script::default())
                 .build();
             100
@@ -446,7 +446,7 @@ fn test_genesis_transaction_fetch() {
     let genesis_block = BlockBuilder::default()
         .dao(dao)
         .transaction(tx)
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .build();
 
     let consensus = ConsensusBuilder::default()
@@ -578,10 +578,10 @@ fn prepare_context_chain(
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-            .timestamp((parent.timestamp() + timestep).into())
-            .compact_target(epoch.compact_target().into())
+            .number(parent.number() + 1)
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .timestamp(parent.timestamp() + timestep)
+            .compact_target(epoch.compact_target())
             .transactions(transactions)
             .dao(dao)
             .build();
@@ -618,10 +618,10 @@ fn prepare_context_chain(
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
             .uncles(uncles)
-            .number((parent.number() + 1).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-            .timestamp((parent.timestamp() + timestep).into())
-            .compact_target(epoch.compact_target().into())
+            .number(parent.number() + 1)
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .timestamp(parent.timestamp() + timestep)
+            .compact_target(epoch.compact_target())
             .transactions(transactions)
             .dao(dao)
             .build();
@@ -644,7 +644,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)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .transaction(cellbase)
         .dao(dao)
         .build();
@@ -737,7 +737,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)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .transaction(cellbase)
         .dao(dao)
         .build();
@@ -791,7 +791,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)).into())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .transaction(cellbase)
         .dao(dao)
         .build();
diff --git a/chain/src/tests/block_assembler.rs b/chain/src/tests/block_assembler.rs
index 3748d67936..bc3627cbd3 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::{Block, CellInput, CellOutput, CellOutputBuilder, CellbaseWitness, OutPoint},
+    packed::{self, 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).into())
-        .number(number.into())
-        .epoch(epoch.number_with_fraction(number).into())
-        .compact_target(epoch.compact_target().into())
-        .nonce(nonce.into())
+        .timestamp(parent_header.timestamp() + 10)
+        .number(number)
+        .epoch(epoch.number_with_fraction(number))
+        .compact_target(epoch.compact_target())
+        .nonce(nonce)
         .dao(dao)
         .build();
 
     BlockBuilder::default()
         .header(header)
         .transaction(cellbase)
-        .proposal([1; 10].into())
+        .proposal([1; 10])
         .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().into())
+                .capacity(epoch.block_reward(number).unwrap())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build()
 }
 
@@ -383,7 +383,7 @@ fn build_tx(parent_tx: &TransactionView, inputs: &[u32], outputs_len: usize) ->
             (0..outputs_len)
                 .map(|_| {
                     CellOutputBuilder::default()
-                        .capacity(per_output_capacity.into())
+                        .capacity(per_output_capacity)
                         .build()
                 })
                 .collect::<Vec<CellOutput>>(),
diff --git a/chain/src/tests/cell.rs b/chain/src/tests/cell.rs
index 74efb94358..fc9438c542 100644
--- a/chain/src/tests/cell.rs
+++ b/chain/src/tests/cell.rs
@@ -35,12 +35,8 @@ pub(crate) fn create_cellbase(
         builder.build()
     } else {
         builder
-            .output(
-                CellOutputBuilder::default()
-                    .capacity(capacity.into())
-                    .build(),
-            )
-            .output_data(Bytes::new().into())
+            .output(CellOutputBuilder::default().capacity(capacity).build())
+            .output_data(Bytes::new())
             .build()
     }
 }
@@ -66,10 +62,10 @@ pub(crate) fn gen_block(
 
     let block = BlockBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp((parent_header.timestamp() + 20_000).into())
-        .number(number.into())
-        .compact_target(epoch.compact_target().into())
-        .epoch(epoch.number_with_fraction(number).into())
+        .timestamp(parent_header.timestamp() + 20_000)
+        .number(number)
+        .compact_target(epoch.compact_target())
+        .epoch(epoch.number_with_fraction(number))
         .transactions(txs)
         .build();
 
@@ -88,11 +84,11 @@ pub(crate) fn create_transaction(parent: &TransactionView, index: u32) -> Transa
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
                 .build(),
         )
         .input(CellInput::new(OutPoint::new(parent.hash(), index), 0))
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build()
 }
 
@@ -104,11 +100,11 @@ fn test_block_cells_update() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx, &issue_tx]).unwrap();
@@ -116,7 +112,7 @@ fn test_block_cells_update() {
     let genesis_block = BlockBuilder::default()
         .transaction(always_success_tx)
         .transaction(issue_tx.clone())
-        .compact_target(DIFF_TWO.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/delay_verify.rs b/chain/src/tests/delay_verify.rs
index 88f57bf650..b30e9b79b2 100644
--- a/chain/src/tests/delay_verify.rs
+++ b/chain/src/tests/delay_verify.rs
@@ -286,9 +286,9 @@ fn test_full_dead_transaction() {
 
     let block = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .compact_target((compact_target - 1).into())
+        .number(parent.number() + 1)
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .compact_target(compact_target - 1)
         .dao(dao)
         .transaction(cellbase_tx)
         .build();
@@ -326,9 +326,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number((parent.number() + 1).into())
-                    .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                    .compact_target((compact_target - 1).into())
+                    .number(parent.number() + 1)
+                    .epoch(epoch.number_with_fraction(parent.number() + 1))
+                    .compact_target(compact_target - 1)
                     .dao(dao)
                     .transactions(transactions)
                     .proposals(vec![tx1.proposal_short_id()])
@@ -347,9 +347,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number((parent.number() + 1).into())
-                    .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                    .compact_target((compact_target - 1).into())
+                    .number(parent.number() + 1)
+                    .epoch(epoch.number_with_fraction(parent.number() + 1))
+                    .compact_target(compact_target - 1)
                     .dao(dao)
                     .transactions(transactions)
                     .build()
@@ -364,9 +364,9 @@ fn test_full_dead_transaction() {
                 );
                 BlockBuilder::default()
                     .parent_hash(parent.hash())
-                    .number((parent.number() + 1).into())
-                    .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                    .compact_target((compact_target - 1).into())
+                    .number(parent.number() + 1)
+                    .epoch(epoch.number_with_fraction(parent.number() + 1))
+                    .compact_target(compact_target - 1)
                     .dao(dao)
                     .transactions(transactions)
                     .build()
@@ -406,9 +406,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).into())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                        .compact_target((compact_target - 1).into())
+                        .number(parent.number() + 1)
+                        .epoch(epoch.number_with_fraction(parent.number() + 1))
+                        .compact_target(compact_target - 1)
                         .dao(dao)
                         .transactions(transactions)
                         .proposals(vec![tx2.proposal_short_id(), tx3.proposal_short_id()])
@@ -428,9 +428,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).into())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                        .compact_target((compact_target - 1).into())
+                        .number(parent.number() + 1)
+                        .epoch(epoch.number_with_fraction(parent.number() + 1))
+                        .compact_target(compact_target - 1)
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -447,9 +447,9 @@ fn test_full_dead_transaction() {
 
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).into())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                        .compact_target((compact_target - 1).into())
+                        .number(parent.number() + 1)
+                        .epoch(epoch.number_with_fraction(parent.number() + 1))
+                        .compact_target(compact_target - 1)
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -478,9 +478,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).into())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                        .compact_target((compact_target - 1).into())
+                        .number(parent.number() + 1)
+                        .epoch(epoch.number_with_fraction(parent.number() + 1))
+                        .compact_target(compact_target - 1)
                         .dao(dao)
                         .proposals(vec![tx2.proposal_short_id(), tx3.proposal_short_id()])
                         .transactions(transactions)
@@ -500,9 +500,9 @@ fn test_full_dead_transaction() {
                     );
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).into())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                        .compact_target((compact_target - 1).into())
+                        .number(parent.number() + 1)
+                        .epoch(epoch.number_with_fraction(parent.number() + 1))
+                        .compact_target(compact_target - 1)
                         .dao(dao)
                         .transactions(transactions)
                         .build()
@@ -519,9 +519,9 @@ fn test_full_dead_transaction() {
 
                     BlockBuilder::default()
                         .parent_hash(parent.hash())
-                        .number((parent.number() + 1).into())
-                        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-                        .compact_target((compact_target - 1).into())
+                        .number(parent.number() + 1)
+                        .epoch(epoch.number_with_fraction(parent.number() + 1))
+                        .compact_target(compact_target - 1)
                         .dao(dao)
                         .transactions(transactions)
                         .build()
diff --git a/chain/src/tests/dep_cell.rs b/chain/src/tests/dep_cell.rs
index 6b88d0b476..ff3572e692 100644
--- a/chain/src/tests/dep_cell.rs
+++ b/chain/src/tests/dep_cell.rs
@@ -45,7 +45,7 @@ pub(crate) fn build_tx(
             (0..outputs_len)
                 .map(|_| {
                     CellOutputBuilder::default()
-                        .capacity(per_output_capacity.into())
+                        .capacity(per_output_capacity)
                         .lock(always_success_script.clone())
                         .build()
                 })
@@ -79,18 +79,18 @@ fn test_package_txs_with_deps() {
         .input(CellInput::new(OutPoint::null(), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
-        .output_data(Bytes::new().into())
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
+        .output_data(Bytes::new())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
-        .output_data(Bytes::new().into())
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
+        .output_data(Bytes::new())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(5_000).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/find_fork.rs b/chain/src/tests/find_fork.rs
index 78af9bfb97..6c9fdfb6b7 100644
--- a/chain/src/tests/find_fork.rs
+++ b/chain/src/tests/find_fork.rs
@@ -429,10 +429,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block1 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .compact_target(parent.compact_target().into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .nonce(1u128.into())
+        .number(parent.number() + 1)
+        .compact_target(parent.compact_target())
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .nonce(1u128)
         .uncle(uncle)
         .build();
     chain_controller
@@ -448,10 +448,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block2 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .compact_target(parent.compact_target().into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .nonce(2u128.into())
+        .number(parent.number() + 1)
+        .compact_target(parent.compact_target())
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .nonce(2u128)
         .build();
     parent = new_block2.clone();
     chain_controller
@@ -464,10 +464,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block3 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .compact_target(parent.compact_target().into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .nonce(2u128.into())
+        .number(parent.number() + 1)
+        .compact_target(parent.compact_target())
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .nonce(2u128)
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block3), Switch::DISABLE_ALL)
@@ -482,10 +482,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block4 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .compact_target(parent.compact_target().into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .nonce(1u128.into())
+        .number(parent.number() + 1)
+        .compact_target(parent.compact_target())
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .nonce(1u128)
         .build();
     chain_controller
         .blocking_process_block_with_switch(Arc::new(new_block4.clone()), Switch::DISABLE_ALL)
@@ -499,10 +499,10 @@ fn repeatedly_switch_fork() {
         .epoch();
     let new_block5 = BlockBuilder::default()
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .compact_target(parent.compact_target().into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .nonce(1u128.into())
+        .number(parent.number() + 1)
+        .compact_target(parent.compact_target())
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .nonce(1u128)
         .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 24c50a955f..108b89f829 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.into())
+        .output_data(load_is_even_data)
         .output(is_even_lib_cell.clone())
-        .output_data(is_even_lib_data.into())
+        .output_data(is_even_lib_data)
         .build()
 }
 
@@ -46,10 +46,10 @@ pub(crate) fn create_call_load_is_even_tx(parent: &TransactionView, index: u32)
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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())
@@ -73,7 +73,7 @@ fn test_load_code() {
     };
 
     let lock_script = Script::new_builder()
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data)
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
@@ -134,7 +134,7 @@ fn test_load_code_with_snapshot() {
     };
 
     let lock_script = Script::new_builder()
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data)
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
@@ -213,7 +213,7 @@ fn _test_load_code_with_snapshot_after_hardfork(script_type: ScriptHashType) {
     };
 
     let lock_script = Script::new_builder()
-        .hash_type(script_type.into())
+        .hash_type(script_type)
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(lock_script)
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/load_input_cell_data.rs b/chain/src/tests/load_input_cell_data.rs
index 67e15590b2..8e711fb25c 100644
--- a/chain/src/tests/load_input_cell_data.rs
+++ b/chain/src/tests/load_input_cell_data.rs
@@ -35,11 +35,11 @@ pub(crate) fn create_load_input_one_byte_transaction(
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
                 .lock(load_input_one_byte_script.clone())
                 .build(),
         )
-        .output_data(Bytes::from(b"1".to_vec()).into())
+        .output_data(Bytes::from(b"1".to_vec()))
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(load_input_one_byte_script.clone())
                 .build(),
         )
-        .output_data(Bytes::from(b"1".to_vec()).into())
+        .output_data(Bytes::from(b"1".to_vec()))
         .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.into())
+        .compact_target(DIFF_TWO)
         .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 f445dd2d19..ac0502c7e8 100644
--- a/chain/src/tests/load_input_data_hash_cell.rs
+++ b/chain/src/tests/load_input_data_hash_cell.rs
@@ -35,11 +35,11 @@ pub(crate) fn create_load_input_data_hash_transaction(
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
                 .lock(load_input_data_hash_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(load_input_data_hash_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .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 41af7bf1a5..03cbbb5171 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.into())
+                    .capacity(capacity)
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .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).into())
-        .number(number.into())
-        .compact_target(epoch.compact_target().into())
-        .epoch(epoch.number_with_fraction(number).into())
+        .timestamp(parent_header.timestamp() + 20_000)
+        .number(number)
+        .compact_target(epoch.compact_target())
+        .epoch(epoch.number_with_fraction(number))
         .transactions(txs)
         .build();
 
@@ -101,7 +101,7 @@ pub(crate) fn create_transaction(
     let mut builder = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
                 .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().into())
+        builder = builder.output_data(Bytes::new())
     }
     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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
diff --git a/chain/src/tests/orphan_block_pool.rs b/chain/src/tests/orphan_block_pool.rs
index bc0ba1ceb9..5e6aa45775 100644
--- a/chain/src/tests/orphan_block_pool.rs
+++ b/chain/src/tests/orphan_block_pool.rs
@@ -5,7 +5,6 @@ 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;
@@ -16,10 +15,14 @@ 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().pack())
-        .number(number.pack())
-        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).pack())
-        .nonce((parent_header.nonce() + 1).pack())
+        .timestamp(unix_time_as_millis())
+        .number(number)
+        .epoch(EpochNumberWithFraction::new(
+            number / 1000,
+            number % 1000,
+            1000,
+        ))
+        .nonce(parent_header.nonce() + 1)
         .build();
     LonelyBlock {
         block: Arc::new(block),
@@ -238,10 +241,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().pack())
-            .number((parent.number() + 1).pack())
-            .epoch(deprecated.clone().pack())
-            .nonce((parent.nonce() + 1).pack())
+            .timestamp(unix_time_as_millis())
+            .number(parent.number() + 1)
+            .epoch(deprecated)
+            .nonce(parent.nonce() + 1)
             .build();
 
         parent = new_block.header();
diff --git a/chain/src/tests/reward.rs b/chain/src/tests/reward.rs
index a9dc168194..f11c7d1792 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).into())
+                    .capacity(reward.unwrap_or(capacity))
                     .lock(reward_lock)
                     .build(),
             )
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .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).into())
-        .number(number.into())
-        .compact_target(epoch.compact_target().into())
-        .epoch(epoch.number_with_fraction(number).into())
+        .timestamp(parent_header.timestamp() + 20_000)
+        .number(number)
+        .compact_target(epoch.compact_target())
+        .epoch(epoch.number_with_fraction(number))
         .dao(dao)
         .transactions(txs)
         .uncles(uncles)
@@ -120,11 +120,11 @@ pub(crate) fn create_transaction(parent: &TransactionView, index: u32) -> Transa
     TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(input_cap.safe_sub(TX_FEE).unwrap().into())
+                .capacity(input_cap.safe_sub(TX_FEE).unwrap())
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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).into())
+                .capacity(capacity_bytes!(5_000))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .compact_target(DIFF_TWO)
         .dao(dao)
         .build();
 
@@ -181,14 +181,14 @@ fn finalize_reward() {
     let bob = ScriptBuilder::default()
         .args(bob_args)
         .code_hash(always_success_script.code_hash())
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data)
         .build();
 
     let alice_args: packed::Bytes = Bytes::from(b"a11ce".to_vec()).into();
     let alice = ScriptBuilder::default()
         .args(alice_args)
         .code_hash(always_success_script.code_hash())
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data)
         .build();
 
     for i in 1..23 {
diff --git a/chain/src/tests/util.rs b/chain/src/tests/util.rs
index fae0de4d81..dcfc8df14d 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).into())
+                            .capacity(capacity_bytes!(50_000))
                             .lock(always_success_script.clone())
                             .build(),
                     )
-                    .output_data(data.into())
+                    .output_data(data)
                     .build()
             })
             .collect();
 
         let genesis_block = BlockBuilder::default()
             .dao(dao)
-            .compact_target(DIFF_TWO.into())
+            .compact_target(DIFF_TWO)
             .transaction(tx)
             .transactions(transactions)
             .build();
diff --git a/chain/src/verify.rs b/chain/src/verify.rs
index 1b2a007aa1..3b6fb4eea9 100644
--- a/chain/src/verify.rs
+++ b/chain/src/verify.rs
@@ -203,9 +203,7 @@ impl ConsumeUnverifiedBlockProcessor {
             match *assume_valid_target {
                 Some(ref target) => {
                     // if the target has been reached, delete it
-                    if target
-                        == &ckb_types::prelude::Unpack::<H256>::unpack(&BlockView::hash(block))
-                    {
+                    if target == &Into::<H256>::into(&BlockView::hash(block)) {
                         assume_valid_target.take();
                         Switch::NONE
                     } else {
diff --git a/devtools/ci/ci_main.sh b/devtools/ci/ci_main.sh
index 33242b3035..cd9c18edb4 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://www.openssl.org/source/openssl-3.1.3.tar.gz
+    curl -LO https://openssl.org/source/old/3.1/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 d600e760a4..55034f841f 100644
--- a/miner/src/miner.rs
+++ b/miner/src/miner.rs
@@ -128,10 +128,7 @@ 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.into())
-            .build();
+        let header = Header::new_builder().raw(raw_header).nonce(nonce).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 c5f16f025c..85d23c4287 100644
--- a/network/src/protocols/discovery/protocol.rs
+++ b/network/src/protocols/discovery/protocol.rs
@@ -32,18 +32,16 @@ impl DiscoveryMessage {
                 listen_port,
                 required_flags,
             } => {
-                let version = version.into();
-                let count = count.into();
                 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].into())
-                            .nth1(port_le[1].into())
+                            .nth0(port_le[0])
+                            .nth1(port_le[1])
                             .build()
                     }))
                     .build();
-                let required_flags = required_flags.bits().into();
+                let required_flags = required_flags.bits();
                 let get_node = packed::GetNodes2::new_builder()
                     .listen_port(listen_port)
                     .count(count)
@@ -70,7 +68,7 @@ impl DiscoveryMessage {
                         )
                     }
                     let bytes_vec = packed::BytesVec::new_builder().set(vec_addrs).build();
-                    let flags = item.flags.bits().into();
+                    let flags = item.flags.bits();
                     let node = packed::Node2::new_builder()
                         .addresses(bytes_vec)
                         .flags(flags)
diff --git a/network/src/protocols/identify/mod.rs b/network/src/protocols/identify/mod.rs
index 0c3a0bb8f7..074768ec08 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().into())
-                .flag(flags.bits().into())
-                .client_version(client_version.as_str().into())
+                .name(name.as_str())
+                .flag(flags.bits())
+                .client_version(client_version.as_str())
                 .build()
                 .as_bytes(),
             name,
diff --git a/network/src/protocols/ping.rs b/network/src/protocols/ping.rs
index 984dbf2a15..e62dfb7cba 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].into())
-            .nth1(nonce_le[1].into())
-            .nth2(nonce_le[2].into())
-            .nth3(nonce_le[3].into())
+            .nth0(nonce_le[0])
+            .nth1(nonce_le[1])
+            .nth2(nonce_le[2])
+            .nth3(nonce_le[3])
             .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].into())
-            .nth1(nonce_le[1].into())
-            .nth2(nonce_le[2].into())
-            .nth3(nonce_le[3].into())
+            .nth0(nonce_le[0])
+            .nth1(nonce_le[1])
+            .nth2(nonce_le[2])
+            .nth3(nonce_le[3])
             .build();
         let pong = packed::Pong::new_builder().nonce(nonce).build();
         let payload = packed::PingPayload::new_builder().set(pong).build();
diff --git a/rpc/src/module/miner.rs b/rpc/src/module/miner.rs
index c1df3387ac..506ba44665 100644
--- a/rpc/src/module/miner.rs
+++ b/rpc/src/module/miner.rs
@@ -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().into())
+                .extension(block.extension())
                 .parent_chain_root(parent_chain_root)
                 .build();
             let light_client_message = {
diff --git a/rpc/src/module/net.rs b/rpc/src/module/net.rs
index 54276a82e8..dd1fee9c33 100644
--- a/rpc/src/module/net.rs
+++ b/rpc/src/module/net.rs
@@ -741,7 +741,11 @@ impl NetRpc for NetRpcImpl {
             ibd: chain.is_initial_block_download(),
             assume_valid_target_reached: shared.assume_valid_target().is_none(),
             assume_valid_target: Into::<packed::Byte32>::into(
-                state.assume_valid_target_specified().unwrap_or_default(),
+                shared
+                    .assume_valid_target_specified()
+                    .as_ref()
+                    .clone()
+                    .unwrap_or_default(),
             )
             .into(),
             min_chain_work: min_chain_work.into(),
@@ -752,9 +756,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().unpack(),
+            unverified_tip_hash: unverified_tip.hash().into(),
             tip_number: chain.tip_number().into(),
-            tip_hash: chain.tip_hash().unpack(),
+            tip_hash: chain.tip_hash().into(),
             fast_time: fast_time.into(),
             normal_time: normal_time.into(),
             low_time: low_time.into(),
diff --git a/rpc/src/module/test.rs b/rpc/src/module/test.rs
index 2e2c20707d..a6acf8f08a 100644
--- a/rpc/src/module/test.rs
+++ b/rpc/src/module/test.rs
@@ -800,7 +800,7 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
 
         let tx_hash = tx.hash();
         match submit_tx.unwrap() {
-            Ok(_) => Ok(tx_hash.unpack()),
+            Ok(_) => Ok(tx_hash.into()),
             Err(reject) => Err(RPCError::from_submit_transaction_reject(&reject)),
         }
     }
diff --git a/rpc/src/tests/examples.rs b/rpc/src/tests/examples.rs
index 0e33e0ac9e..0b2fbd69dc 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::{CellDep, CellInput, CellOutputBuilder, OutPoint},
+    packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint},
     prelude::*,
     H256,
 };
@@ -105,7 +105,7 @@ fn construct_example_transaction() -> TransactionView {
     let previous_output = OutPoint::new(EXAMPLE_TX_PARENT.clone().into(), 0);
     let input = CellInput::new(previous_output, 0);
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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(Default::default())
+        .output_data(packed::Bytes::default())
         .cell_dep(cell_dep)
         .header_dep(always_success_consensus().genesis_hash())
         .build()
diff --git a/rpc/src/tests/mod.rs b/rpc/src/tests/mod.rs
index 71c54689a7..800066113b 100644
--- a/rpc/src/tests/mod.rs
+++ b/rpc/src/tests/mod.rs
@@ -198,10 +198,10 @@ fn next_block(shared: &Shared, parent: &HeaderView) -> BlockView {
     BlockBuilder::default()
         .transaction(cellbase)
         .parent_hash(parent.hash())
-        .number((parent.number() + 1).into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .timestamp((parent.timestamp() + 1).into())
-        .compact_target(epoch.compact_target().into())
+        .number(parent.number() + 1)
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .timestamp(parent.timestamp() + 1)
+        .compact_target(epoch.compact_target())
         .dao(dao)
         .build()
 }
@@ -215,7 +215,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.to_owned().into())
+        .output_data(always_success_cell_data)
         .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 a2f7981d30..29b0a6d252 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::{CellDep, CellInput, CellOutputBuilder, OutPoint},
+    packed::{self, 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).into())
+                    .timestamp(parent.header().timestamp() + 1)
                     .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).into())
+            .capacity(capacity_bytes!(100))
             .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(Default::default())
+            .output_data(packed::Bytes::default())
             .cell_dep(cell_dep)
             .build();
 
diff --git a/rpc/src/tests/module/pool.rs b/rpc/src/tests/module/pool.rs
index 808ea89486..560d3d6bc0 100644
--- a/rpc/src/tests/module/pool.rs
+++ b/rpc/src/tests/module/pool.rs
@@ -151,8 +151,7 @@ fn test_send_transaction_exceeded_maximum_ancestors_count() {
                 Capacity::bytes(1000)
                     .unwrap()
                     .safe_sub(Capacity::shannons(i * 41 * 1000))
-                    .unwrap()
-                    .into(),
+                    .unwrap(),
             )
             .lock(always_success_cell().2.clone())
             .build();
@@ -162,7 +161,7 @@ fn test_send_transaction_exceeded_maximum_ancestors_count() {
         let tx = TransactionBuilder::default()
             .input(input)
             .output(output)
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .cell_dep(cell_dep)
             .build();
         let new_tx: ckb_jsonrpc_types::Transaction = tx.data().into();
@@ -191,8 +190,8 @@ fn build_tx(
 ) -> core::TransactionView {
     let lock = packed::ScriptBuilder::default()
         .code_hash(code_hash.clone())
-        .hash_type(hash_type.into())
-        .args(args.as_slice().into())
+        .hash_type(hash_type)
+        .args(args.as_slice())
         .build();
     core::TransactionBuilder::default()
         .output(packed::CellOutput::new_builder().lock(lock).build())
@@ -208,18 +207,18 @@ fn build_tx_with_type(
 ) -> core::TransactionView {
     let lock = packed::ScriptBuilder::default()
         .code_hash(lock_code_hash.clone())
-        .hash_type(lock_hash_type.into())
-        .args(lock_args.pack())
+        .hash_type(lock_hash_type)
+        .args(lock_args)
         .build();
     let type_ = packed::ScriptBuilder::default()
         .code_hash(type_code_hash.clone())
-        .hash_type(type_hash_type.into())
+        .hash_type(type_hash_type)
         .build();
     core::TransactionBuilder::default()
         .output(
             packed::CellOutput::new_builder()
                 .lock(lock)
-                .type_(Some(type_).into())
+                .type_(Some(type_))
                 .build(),
         )
         .build()
diff --git a/rpc/src/tests/setup.rs b/rpc/src/tests/setup.rs
index 35d4a9b92b..03a1675973 100644
--- a/rpc/src/tests/setup.rs
+++ b/rpc/src/tests/setup.rs
@@ -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.into())
-        .compact_target(GENESIS_TARGET.into())
-        .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).into())
+        .timestamp(GENESIS_TIMESTAMP)
+        .compact_target(GENESIS_TARGET)
+        .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0))
         .dao(dao)
         .transaction(always_success_tx)
         .build();
@@ -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.into())
-                    .min_version(Some("0.0.1".to_string()).into())
-                    .max_version(Some("1.0.0".to_string()).into())
-                    .priority(1u32.into())
-                    .notice_until((ALERT_UNTIL_TIMESTAMP * 1000).into())
-                    .message("An example alert message!".into())
+                    .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!")
                     .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).into())
+                    .timestamp(parent.header().timestamp() + 1)
                     .build(),
             )
             .build();
diff --git a/script/fuzz/fuzz_targets/syscall_spawn.rs b/script/fuzz/fuzz_targets/syscall_spawn.rs
index 8782bee23a..7c87e9f879 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.pack())
-        .block_epoch(0u64.pack())
+        .block_number(1u64)
+        .block_epoch(0u64)
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.pack())
+                .index(1u32)
                 .build(),
         )
         .build()
-        .unpack()
+        .into()
 }
 
 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.pack(), child_witness.pack()];
+    let witnesses = vec![parent_witness.into(), child_witness.into()];
 
     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().pack())
+            .capacity(Capacity::bytes(data.len()).unwrap())
             .build(),
         data,
     )
     .transaction_info(mock_transaction_info())
-    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
+    .out_point(OutPoint::new(h256!("0x0"), 0))
     .build();
 
     let input_cell = CellMetaBuilder::from_cell_output(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100))
             .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.pack()).build());
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0).build());
     let verifier = TransactionScriptsVerifier::new(
         rtx.into(),
         provider,
diff --git a/script/src/syscalls/tests/utils.rs b/script/src/syscalls/tests/utils.rs
index b8e43abf03..920f362265 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.into());
+    let builder = CellOutput::new_builder().capacity(capacity);
     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 00ca304753..99bb2ec7b1 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_1.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
@@ -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.into()).build(),
+        cell_output: CellOutput::new_builder().capacity(capacity).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.into()).build(),
+        cell_output: CellOutput::new_builder().capacity(100).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.into()).build(),
+        cell_output: CellOutput::new_builder().capacity(100).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).into();
+    let data_hash = blake2b_256(data);
     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.into()).build(),
+        cell_output: CellOutput::new_builder().capacity(100).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.into())
-        .number(2000.into())
-        .epoch(epoch.into())
+        .transactions_root(data_hash)
+        .number(2000)
+        .epoch(epoch)
         .build();
 
     let mut correct_data = [0u8; 8];
@@ -847,9 +847,7 @@ 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.into())
-        .build();
+    let transaction_view = TransactionBuilder::default().output_data(data).build();
 
     let hash = transaction_view.hash();
     let hash_len = 32u64;
@@ -898,9 +896,7 @@ 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.into())
-        .build();
+    let transaction_view = TransactionBuilder::default().output_data(data).build();
 
     let tx = transaction_view.data();
     let tx_len = transaction_view.data().as_slice().len() as u64;
@@ -950,8 +946,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()).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(data.to_owned()))
+        .hash_type(ScriptHashType::Data)
         .build();
     let hash = script.calc_script_hash();
     let data = hash.raw_data();
@@ -1005,8 +1001,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()).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(data.to_owned()))
+        .hash_type(ScriptHashType::Data)
         .build();
     let h = script.calc_script_hash();
     let hash = h.as_bytes();
@@ -1071,8 +1067,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()).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(data.to_owned()))
+        .hash_type(ScriptHashType::Data)
         .build();
     let lock = script.as_slice();
 
@@ -1139,8 +1135,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()).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(data.to_owned()))
+        .hash_type(ScriptHashType::Data)
         .build();
     let type_ = script.as_slice();
 
@@ -1149,7 +1145,7 @@ fn _test_load_input_type_script(data: &[u8]) -> Result<(), TestCaseError> {
         .cell_output
         .clone()
         .as_builder()
-        .type_(Some(script.to_owned()).into())
+        .type_(Some(script.to_owned()))
         .build();
     input_cell.cell_output = output_with_type;
 
@@ -1207,8 +1203,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()).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(data.to_owned()))
+        .hash_type(ScriptHashType::Data)
         .build();
 
     let type_h = script.calc_script_hash();
@@ -1219,7 +1215,7 @@ fn _test_load_input_type_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
         .cell_output
         .clone()
         .as_builder()
-        .type_(Some(script).into())
+        .type_(Some(script))
         .build();
     input_cell.cell_output = output_with_type;
     let outputs = Arc::new(vec![]);
@@ -1397,7 +1393,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()).into())
+        .args(Bytes::from(data.to_owned()))
         .build();
     let script_correct_data = script.as_slice();
 
@@ -1458,7 +1454,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.pack())
+            .output_data(data.clone())
             .build(),
         resolved_cell_deps: vec![dep_cell],
         resolved_inputs: vec![input_cell],
@@ -1531,7 +1527,7 @@ fn _test_load_cell_data(
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default()
-            .output_data(data.pack())
+            .output_data(data.clone())
             .build(),
         resolved_cell_deps: vec![dep_cell],
         resolved_inputs: vec![input_cell],
@@ -1962,15 +1958,10 @@ 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).into();
+    let hash = blake2b_256(&data);
     let input = CellInput::new_builder()
-        .previous_output(
-            OutPoint::new_builder()
-                .tx_hash(hash)
-                .index(0u32.into())
-                .build(),
-        )
-        .since(10u64.into())
+        .previous_output(OutPoint::new_builder().tx_hash(hash).index(0u32).build())
+        .since(10u64)
         .build();
     let previous_output = input.previous_output();
 
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_2.rs b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
index 8d4ae72ca3..07d2eb6db2 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_2.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
@@ -87,7 +87,7 @@ fn _test_load_extension(
             block_epoch: header.epoch(),
             index: 1,
         }),
-        cell_output: CellOutput::new_builder().capacity(100.into()).build(),
+        cell_output: CellOutput::new_builder().capacity(100).build(),
         data_bytes: 0,
         mem_cell_data: None,
         mem_cell_data_hash: None,
diff --git a/script/src/verify.rs b/script/src/verify.rs
index d7a1b88e7f..a79e3d8c92 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.into())
+                        .index(index)
                         .build();
                     let data_hash = CellOutput::calc_data_hash(&data);
                     CellMeta {
@@ -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.pack()
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.into()
             && 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 f65628231a..2cfa0ea806 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).into())
+        .capacity(capacity_bytes!(100))
         .lock(always_success_script.clone())
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -74,7 +74,7 @@ fn check_signature() {
         .build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().into())
+        .capacity(Capacity::bytes(data.len()).unwrap())
         .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).into())
-        .code_hash(code_hash.into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(args))
+        .code_hash(code_hash)
+        .hash_type(ScriptHashType::Data)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -94,7 +94,7 @@ fn check_signature() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -143,16 +143,13 @@ fn check_signature_referenced_via_type_hash() {
         .build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().into())
-        .type_(
-            Some(
-                Script::new_builder()
-                    .code_hash(h256!("0x123456abcd90").into())
-                    .hash_type(ScriptHashType::Data.into())
-                    .build(),
-            )
-            .into(),
-        )
+        .capacity(Capacity::bytes(data.len()).unwrap())
+        .type_(Some(
+            Script::new_builder()
+                .code_hash(h256!("0x123456abcd90"))
+                .hash_type(ScriptHashType::Data)
+                .build(),
+        ))
         .build();
     let type_hash = output.type_().to_opt().as_ref().unwrap().calc_script_hash();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
@@ -161,9 +158,9 @@ fn check_signature_referenced_via_type_hash() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).into())
+        .args(Bytes::from(args))
         .code_hash(type_hash)
-        .hash_type(ScriptHashType::Type.into())
+        .hash_type(ScriptHashType::Type)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -173,7 +170,7 @@ fn check_signature_referenced_via_type_hash() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -217,16 +214,16 @@ fn check_invalid_signature() {
     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().into())
+        .capacity(Capacity::bytes(data.len()).unwrap())
         .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).into())
-        .code_hash(code_hash.into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(args))
+        .code_hash(code_hash)
+        .hash_type(ScriptHashType::Data)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -236,7 +233,7 @@ fn check_invalid_signature() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -275,9 +272,9 @@ fn check_invalid_dep_reference() {
 
     let script_code_hash: Byte32 = blake2b_256(&buffer).into();
     let script = Script::new_builder()
-        .args(Bytes::from(args).into())
+        .args(Bytes::from(args))
         .code_hash(script_code_hash.clone())
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -287,7 +284,7 @@ fn check_invalid_dep_reference() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -325,7 +322,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).into())
+        .capacity(capacity_bytes!(100))
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -337,18 +334,18 @@ fn check_output_contract() {
     .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).into())
-        .code_hash(blake2b_256(&buffer).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(args))
+        .code_hash(blake2b_256(&buffer))
+        .hash_type(ScriptHashType::Data)
         .build();
     let output_data = Bytes::default();
     let output = CellOutputBuilder::default()
         .lock(
             Script::new_builder()
-                .hash_type(ScriptHashType::Data.into())
+                .hash_type(ScriptHashType::Data)
                 .build(),
         )
-        .type_(Some(script).into())
+        .type_(Some(script))
         .build();
 
     let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
@@ -358,7 +355,7 @@ fn check_output_contract() {
     let dep_cell = {
         let data = Bytes::from(buffer);
         let output = CellOutputBuilder::default()
-            .capacity(Capacity::bytes(data.len()).unwrap().into())
+            .capacity(Capacity::bytes(data.len()).unwrap())
             .build();
         CellMetaBuilder::from_cell_output(output, data)
             .transaction_info(default_transaction_info())
@@ -369,7 +366,7 @@ fn check_output_contract() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(output_data.into())
+        .output_data(output_data)
         .cell_dep(cell_dep)
         .build();
 
@@ -406,7 +403,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).into())
+        .capacity(capacity_bytes!(100))
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -418,12 +415,12 @@ fn check_invalid_output_contract() {
     .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).into())
-        .code_hash(blake2b_256(&buffer).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(args))
+        .code_hash(blake2b_256(&buffer))
+        .hash_type(ScriptHashType::Data)
         .build();
     let output = CellOutputBuilder::default()
-        .type_(Some(script.clone()).into())
+        .type_(Some(script.clone()))
         .build();
 
     let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
@@ -431,7 +428,7 @@ fn check_invalid_output_contract() {
     let dep_cell = {
         let dep_cell_data = Bytes::from(buffer);
         let output = CellOutputBuilder::default()
-            .capacity(Capacity::bytes(dep_cell_data.len()).unwrap().into())
+            .capacity(Capacity::bytes(dep_cell_data.len()).unwrap())
             .build();
         CellMetaBuilder::from_cell_output(output, dep_cell_data)
             .transaction_info(default_transaction_info())
@@ -441,7 +438,7 @@ fn check_invalid_output_contract() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .cell_dep(cell_dep)
         .build();
 
@@ -477,9 +474,9 @@ 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).into())
-        .code_hash(blake2b_256(&buffer).into())
-        .hash_type(ScriptHashType::Data.into())
+        .args(Bytes::from(args))
+        .code_hash(blake2b_256(&buffer))
+        .hash_type(ScriptHashType::Data)
         .build();
 
     let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
@@ -488,7 +485,7 @@ fn check_same_lock_and_type_script_are_executed_twice() {
         .build();
     let data = Bytes::from(buffer);
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().into())
+        .capacity(Capacity::bytes(data.len()).unwrap())
         .build();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data)
         .transaction_info(default_transaction_info())
@@ -502,9 +499,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).into())
+        .capacity(capacity_bytes!(100))
         .lock(script.clone())
-        .type_(Some(script).into())
+        .type_(Some(script))
         .build();
     let dummy_cell = create_dummy_cell(output);
 
@@ -530,22 +527,22 @@ fn check_type_id_one_in_one_out() {
     let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(h256!("0x1111").as_ref()))
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).into())
+        .type_(Some(type_id_script))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -595,22 +592,22 @@ fn check_type_id_one_in_one_out_not_enough_cycles() {
     let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(h256!("0x1111").as_ref()))
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).into())
+        .type_(Some(type_id_script))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -661,7 +658,7 @@ fn check_type_id_creation() {
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
         .build();
 
@@ -675,15 +672,15 @@ fn check_type_id_creation() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash.into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(input_hash)
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).into())
+        .type_(Some(type_id_script))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -727,20 +724,20 @@ fn check_type_id_termination() {
     let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(h256!("0x1111").as_ref()))
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).into())
+        .type_(Some(type_id_script))
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
         .build();
 
@@ -786,7 +783,7 @@ fn check_type_id_invalid_creation() {
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
         .build();
 
@@ -806,15 +803,15 @@ fn check_type_id_invalid_creation() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash.into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(input_hash)
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -862,7 +859,7 @@ fn check_type_id_invalid_creation_length() {
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
         .build();
 
@@ -885,15 +882,15 @@ fn check_type_id_invalid_creation_length() {
     };
 
     let type_id_script = Script::new_builder()
-        .args(input_hash.into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(input_hash)
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -940,27 +937,27 @@ fn check_type_id_one_in_two_out() {
     let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(h256!("0x1111").as_ref()))
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(2000).into())
+        .capacity(capacity_bytes!(2000))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
     let output_cell2 = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -1039,12 +1036,12 @@ fn create_rtx_to_load_code_to_stack_then_reuse(
         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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(dyn_lock_data_hash)
         .args(args)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(dyn_lock_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1111,7 +1108,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).into())
+        .capacity(capacity_bytes!(100))
         .lock(always_success_script.clone())
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -1123,17 +1120,17 @@ fn check_debugger() {
     .build();
 
     let script = Script::new_builder()
-        .code_hash(blake2b_256(&buffer).into())
-        .hash_type(ScriptHashType::Data.into())
+        .code_hash(blake2b_256(&buffer))
+        .hash_type(ScriptHashType::Data)
         .build();
     let output_data = Bytes::default();
     let output = CellOutputBuilder::default()
         .lock(
             Script::new_builder()
-                .hash_type(ScriptHashType::Data.into())
+                .hash_type(ScriptHashType::Data)
                 .build(),
         )
-        .type_(Some(script).into())
+        .type_(Some(script))
         .build();
 
     let dep_out_point = OutPoint::new(h256!("0x123").into(), 8);
@@ -1143,7 +1140,7 @@ fn check_debugger() {
     let dep_cell = {
         let data = Bytes::from(buffer);
         let output = CellOutputBuilder::default()
-            .capacity(Capacity::bytes(data.len()).unwrap().into())
+            .capacity(Capacity::bytes(data.len()).unwrap())
             .build();
         CellMetaBuilder::from_cell_output(output, data)
             .transaction_info(default_transaction_info())
@@ -1154,7 +1151,7 @@ fn check_debugger() {
     let transaction = TransactionBuilder::default()
         .input(input)
         .output(output)
-        .output_data(output_data.into())
+        .output_data(output_data)
         .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 30c8d0f71d..93e94557bc 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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(always_success_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(always_success_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -79,12 +79,12 @@ fn test_b_extension() {
     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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(cpop_lock_data_hash)
         .args(args)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(always_success_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(current_cycles_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(current_cycles_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -503,22 +503,22 @@ fn _check_type_id_one_in_one_out_resume(step_cycles: Cycle) -> Result<(), TestCa
     let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(h256!("0x1111").as_ref()))
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).into())
+        .type_(Some(type_id_script))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -653,22 +653,22 @@ fn _check_type_id_one_in_one_out_resume_with_state(
     let always_success_out_point = OutPoint::new(h256!("0x11").into(), 0);
 
     let type_id_script = Script::new_builder()
-        .args(Bytes::from(h256!("0x1111").as_ref()).into())
-        .code_hash(TYPE_ID_CODE_HASH.into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(Bytes::from(h256!("0x1111").as_ref()))
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let input = CellInput::new(OutPoint::new(h256!("0x1234").into(), 8), 0);
     let input_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(1000).into())
+        .capacity(capacity_bytes!(1000))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script.clone()).into())
+        .type_(Some(type_id_script.clone()))
         .build();
 
     let output_cell = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(990).into())
+        .capacity(capacity_bytes!(990))
         .lock(always_success_script.clone())
-        .type_(Some(type_id_script).into())
+        .type_(Some(type_id_script))
         .build();
 
     let transaction = TransactionBuilder::default()
@@ -1052,12 +1052,12 @@ fn load_code_into_global() {
             load_cell_from_path("testdata/load_is_even_into_global");
 
         let dyn_lock_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type().into())
+            .hash_type(script_version.data_hash_type())
             .code_hash(dyn_lock_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .lock(dyn_lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1108,12 +1108,12 @@ fn load_code_with_snapshot() {
             load_cell_from_path("testdata/load_is_even_with_snapshot");
 
         let dyn_lock_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type().into())
+            .hash_type(script_version.data_hash_type())
             .code_hash(dyn_lock_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .lock(dyn_lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1206,12 +1206,12 @@ fn load_code_with_snapshot_more_times() {
         };
 
         let lock_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type().into())
+            .hash_type(script_version.data_hash_type())
             .code_hash(lock_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .lock(lock_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1343,12 +1343,12 @@ fn test_exec(
             always_success_cell();
 
         let exec_caller_script = Script::new_builder()
-            .hash_type(script_version.data_hash_type().into())
+            .hash_type(script_version.data_hash_type())
             .code_hash(exec_caller_data_hash)
             .args(args)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .lock(exec_caller_script.clone())
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
@@ -1383,8 +1383,8 @@ 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).into())
-                    .type_(Some(exec_caller_script).into())
+                    .capacity(capacity_bytes!(100))
+                    .type_(Some(exec_caller_script))
                     .build();
                 let tx = TransactionBuilder::default()
                     .output(output)
@@ -1394,7 +1394,7 @@ fn test_exec(
             }
             ExecFrom::TxInputCell => {
                 let callee_output = CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .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).into())
+                    .capacity(capacity_bytes!(100))
                     .lock(exec_caller_script)
-                    .type_(Some(always_success_script.clone()).into())
+                    .type_(Some(always_success_script.clone()))
                     .build();
                 let exec_callee_cell_data = exec_callee_cell.mem_cell_data.as_ref().unwrap();
                 let caller_cell =
@@ -1422,25 +1422,25 @@ 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).into())
+                    .capacity(capacity_bytes!(100))
                     .lock(always_success_script.clone())
                     .build();
                 let tx = TransactionBuilder::default()
                     .input(input)
                     .output(callee_output)
-                    .output_data(exec_callee_cell_data.into())
+                    .output_data(exec_callee_cell_data)
                     .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).into())
-                    .type_(Some(exec_caller_script).into())
+                    .capacity(capacity_bytes!(100))
+                    .type_(Some(exec_caller_script))
                     .build();
                 let tx = TransactionBuilder::default()
                     .output(callee_output)
-                    .output_data(exec_callee_cell_data.into())
+                    .output_data(exec_callee_cell_data)
                     .build();
                 (tx, vec![])
             }
@@ -1798,16 +1798,13 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .out_point(dep_out_point.clone())
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().into())
-        .type_(
-            Some(
-                Script::new_builder()
-                    .code_hash(h256!("0x123456abcd90").into())
-                    .hash_type(ScriptHashType::Data.into())
-                    .build(),
-            )
-            .into(),
-        )
+        .capacity(Capacity::bytes(data.len()).unwrap())
+        .type_(Some(
+            Script::new_builder()
+                .code_hash(h256!("0x123456abcd90"))
+                .hash_type(ScriptHashType::Data)
+                .build(),
+        ))
         .build();
     let type_hash = output.type_().to_opt().as_ref().unwrap().calc_script_hash();
     let dep_cell = CellMetaBuilder::from_cell_output(output, data.clone())
@@ -1820,16 +1817,13 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .out_point(dep_out_point2.clone())
         .build();
     let output2 = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(data.len()).unwrap().into())
-        .type_(
-            Some(
-                Script::new_builder()
-                    .code_hash(h256!("0x123456abcd90").into())
-                    .hash_type(ScriptHashType::Data.into())
-                    .build(),
-            )
-            .into(),
-        )
+        .capacity(Capacity::bytes(data.len()).unwrap())
+        .type_(Some(
+            Script::new_builder()
+                .code_hash(h256!("0x123456abcd90"))
+                .hash_type(ScriptHashType::Data)
+                .build(),
+        ))
         .build();
     let dep_cell2 = CellMetaBuilder::from_cell_output(output2, data)
         .transaction_info(default_transaction_info())
@@ -1837,9 +1831,9 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .build();
 
     let script = Script::new_builder()
-        .args(Bytes::from(args).into())
+        .args(Bytes::from(args))
         .code_hash(type_hash)
-        .hash_type(ScriptHashType::Type.into())
+        .hash_type(ScriptHashType::Type)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -1850,7 +1844,7 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
         .build();
 
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(script)
         .build();
     let dummy_cell = create_dummy_cell(output);
@@ -1880,11 +1874,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .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 5006ca1996..e44809e783 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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(data_hash)
-        .args(Bytes::copy_from_slice(args).pack())
+        .args(Bytes::copy_from_slice(args))
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -140,71 +140,6 @@ fn check_vm_version() {
     assert_eq!(result.is_ok(), script_version == ScriptVersion::V2);
 }
 
-#[test]
-fn check_get_memory_limit() {
-    let script_version = SCRIPT_VERSION;
-
-    let (memory_limit_cell, memory_limit_data_hash) =
-        load_cell_from_path("testdata/get_memory_limit");
-
-    let memory_limit_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(memory_limit_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(memory_limit_script)
-        .build();
-
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![memory_limit_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_set_content() {
-    let script_version = SCRIPT_VERSION;
-
-    let (set_content_cell, set_content_data_hash) = load_cell_from_path("testdata/set_content");
-
-    let memory_limit_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(set_content_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(memory_limit_script)
-        .build();
-
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![set_content_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
 #[test]
 fn check_spawn_strcat() {
     let script_version = SCRIPT_VERSION;
@@ -215,110 +150,10 @@ 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().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_spawn_strcat_data_hash() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_strcat_data_hash");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_strcat");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_spawn_get_memory_limit() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_get_memory_limit");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_get_memory_limit");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_spawn_set_content() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_set_content");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_set_content");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -347,11 +182,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -387,11 +222,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -424,11 +259,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -461,11 +296,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -503,11 +338,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -531,161 +366,6 @@ fn check_spawn_recursive() {
     }
 }
 
-#[test]
-fn check_spawn_big_memory_size() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_big_memory_size");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_spawn_big_content_length() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_big_content_length");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_peak_memory_4m_to_32m() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_peak_memory_4m_to_32m");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_peak_memory_2m_to_32m() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_peak_memory_2m_to_32m");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
-#[test]
-fn check_peak_memory_512k_to_32m() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_peak_memory_512k_to_32m");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
 #[test]
 fn check_spawn_snapshot() {
     let script_version = SCRIPT_VERSION;
@@ -698,11 +378,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -739,11 +419,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -818,11 +498,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -875,11 +555,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -933,37 +613,6 @@ fn check_spawn_state() {
     assert!(chunks_count > 1);
 }
 
-#[test]
-fn check_spawn_current_memory() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_current_memory");
-
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
-}
-
 #[test]
 fn check_spawn_current_cycles() {
     let script_version = SCRIPT_VERSION;
@@ -974,11 +623,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1051,19 +700,19 @@ 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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
-        .args(args.pack())
+        .args(args)
         .build();
 
     let always_success_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(always_success_data_hash)
         .build();
 
     let input_spawn_caller = create_dummy_cell(
         CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100))
             .lock(spawn_caller_script.clone())
             .build(),
     );
@@ -1072,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.pack()])
+                    .set_witnesses(vec![spawn_callee_cell_data.into()])
                     .build(),
                 resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
                 resolved_inputs: vec![input_spawn_caller],
@@ -1083,11 +732,11 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             transaction: TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(100).pack())
-                        .type_(Some(spawn_caller_script).pack())
+                        .capacity(capacity_bytes!(100))
+                        .type_(Some(spawn_caller_script))
                         .build(),
                 )
-                .set_witnesses(vec![spawn_callee_cell_data.pack()])
+                .set_witnesses(vec![spawn_callee_cell_data.into()])
                 .build(),
             resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
             resolved_inputs: vec![],
@@ -1101,7 +750,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
         },
         SpawnFrom::TxInputCell => {
             let input_spawn_callee_output = CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).pack())
+                .capacity(capacity_bytes!(1000))
                 .lock(always_success_script)
                 .build();
             let input_spawn_callee = CellMetaBuilder::from_cell_output(
@@ -1120,11 +769,11 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             transaction: TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(100).pack())
+                        .capacity(capacity_bytes!(100))
                         .lock(always_success_script)
                         .build(),
                 )
-                .output_data(spawn_callee_cell_data.pack())
+                .output_data(spawn_callee_cell_data)
                 .build(),
             resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
             resolved_inputs: vec![input_spawn_caller],
@@ -1133,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).pack())
+                    .capacity(capacity_bytes!(100))
                     .lock(spawn_caller_script)
                     .build(),
                 spawn_callee_cell_data.clone(),
@@ -1150,11 +799,11 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             transaction: TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(100).pack())
-                        .type_(Some(spawn_caller_script).pack())
+                        .capacity(capacity_bytes!(100))
+                        .type_(Some(spawn_caller_script))
                         .build(),
                 )
-                .output_data(spawn_callee_cell_data.pack())
+                .output_data(spawn_callee_cell_data)
                 .build(),
             resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
             resolved_inputs: vec![],
@@ -1168,7 +817,7 @@ fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
             }
             ResolvedTransaction {
                 transaction: TransactionBuilder::default()
-                    .set_witnesses(vec![data.pack()])
+                    .set_witnesses(vec![data.into()])
                     .build(),
                 resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
                 resolved_inputs: vec![input_spawn_caller],
@@ -1481,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().into())
+            .hash_type(script_version.data_hash_type() )
             .code_hash(code_dep_hash)
             .build();
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(100).pack())
+            .capacity(capacity_bytes!(100) )
             .lock(spawn_caller_script)
             .build();
         let dummy_cell = create_dummy_cell(output);
 
         let rtx = ResolvedTransaction {
-            transaction: TransactionBuilder::default().witness(data.as_bytes().pack()).build(),
+            transaction: TransactionBuilder::default().witness(data.as_bytes()).build(),
             resolved_cell_deps: vec![code_dep],
             resolved_inputs: vec![dummy_cell],
             resolved_dep_groups: vec![],
@@ -1541,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1594,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(spawn_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(spawn_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1629,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(data_hash)
-        .args(Bytes::copy_from_slice(&args).pack())
+        .args(Bytes::copy_from_slice(&args))
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1684,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1721,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1759,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
@@ -1792,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().into())
+        .hash_type(script_version.data_hash_type())
         .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
+        .capacity(capacity_bytes!(100))
         .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 43b404d195..97ff7f6740 100644
--- a/script/src/verify/tests/utils.rs
+++ b/script/src/verify/tests/utils.rs
@@ -22,7 +22,7 @@ use ckb_types::{
     },
     h256,
     packed::{
-        Byte32, CellDep, CellInput, OutPoint, Script, TransactionInfoBuilder,
+        self, 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().into())
+        .capacity(Capacity::bytes(cell_data.len()).unwrap())
         .build();
     let cell_meta = CellMetaBuilder::from_cell_output(cell_output, cell_data)
         .transaction_info(default_transaction_info())
@@ -107,12 +107,12 @@ pub(crate) fn sign_args(args: &[u8], privkey: &Privkey) -> Signature {
 
 pub(crate) fn default_transaction_info() -> TransactionInfo {
     TransactionInfoBuilder::default()
-        .block_number(1u64.into())
-        .block_epoch(0u64.into())
+        .block_number(1u64)
+        .block_epoch(0u64)
         .key(
             TransactionKeyBuilder::default()
                 .block_hash(Byte32::zero())
-                .index(1u32.into())
+                .index(1u32)
                 .build(),
         )
         .build()
@@ -184,9 +184,7 @@ 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.pack())
-            .build();
+        let header = HeaderView::new_advanced_builder().epoch(epoch).build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
@@ -275,9 +273,7 @@ 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.pack())
-            .build();
+        let header = HeaderView::new_advanced_builder().epoch(epoch).build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
@@ -309,9 +305,7 @@ 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.into())
-            .build();
+        let header = HeaderView::new_advanced_builder().epoch(epoch).build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
         let mut verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
@@ -336,7 +330,7 @@ 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.into())
+        .dep_type(DepType::DepGroup)
         .build();
 
     let input1 = CellInput::new(OutPoint::new(h256!("0x1234").into(), 0), 0);
@@ -351,23 +345,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.into())
-        .code_hash(type_lock_script_code_hash().into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(lock_arg)
+        .code_hash(type_lock_script_code_hash())
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let lock2 = Script::new_builder()
-        .args(lock_arg2.into())
-        .code_hash(type_lock_script_code_hash().into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(lock_arg2)
+        .code_hash(type_lock_script_code_hash())
+        .hash_type(ScriptHashType::Type)
         .build();
 
     let output1 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(lock.clone())
         .build();
     let output2 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(lock2.clone())
         .build();
     let tx = TransactionBuilder::default()
@@ -376,15 +370,15 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .input(input2.clone())
         .output(output1)
         .output(output2)
-        .output_data(Default::default())
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx_hash: H256 = tx.hash().into();
     // sign input1
     let witness = {
         WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).into())
+            .lock(Some(Bytes::from(vec![0u8; 65])))
             .build()
     };
     let witness_len: u64 = witness.as_bytes().len() as u64;
@@ -399,11 +393,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())).into())
+        .lock(Some(Bytes::from(sig.serialize())))
         .build();
     // sign input2
     let witness2 = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])).into())
+        .lock(Some(Bytes::from(vec![0u8; 65])))
         .build();
     let witness2_len: u64 = witness2.as_bytes().len() as u64;
     let mut hasher = new_blake2b();
@@ -417,12 +411,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())).into())
+        .lock(Some(Bytes::from(sig2.serialize())))
         .build();
     let tx = tx
         .as_advanced_builder()
-        .witness(witness.as_bytes().into())
-        .witness(witness2.as_bytes().into())
+        .witness(witness.as_bytes())
+        .witness(witness2.as_bytes())
         .build();
 
     let serialized_size = tx.data().as_slice().len() as u64;
@@ -438,7 +432,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).into())
+        .capacity(capacity_bytes!(100))
         .lock(lock)
         .build();
 
@@ -447,7 +441,7 @@ pub(super) fn random_2_in_2_out_rtx() -> ResolvedTransaction {
         .build();
 
     let input_cell2 = CellOutput::new_builder()
-        .capacity(capacity_bytes!(100).into())
+        .capacity(capacity_bytes!(100))
         .lock(lock2)
         .build();
 
diff --git a/shared/src/shared.rs b/shared/src/shared.rs
index 7f30c5d82b..9687165186 100644
--- a/shared/src/shared.rs
+++ b/shared/src/shared.rs
@@ -277,12 +277,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.into())
+            .index(0u32)
             .build();
 
         let end_t = packed::TransactionKey::new_builder()
             .block_hash(end.clone())
-            .index(TX_INDEX_UPPER_BOUND.into())
+            .index(TX_INDEX_UPPER_BOUND)
             .build();
 
         if let Err(e) = self.store.compact_range(
diff --git a/shared/src/shared_builder.rs b/shared/src/shared_builder.rs
index 155a564a0f..1bb7537d31 100644
--- a/shared/src/shared_builder.rs
+++ b/shared/src/shared_builder.rs
@@ -22,7 +22,6 @@ 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,
 };
@@ -344,7 +343,7 @@ impl SharedBuilder {
         snapshot: &Snapshot,
     ) -> bool {
         if let Some(ref target) = sync_config.assume_valid_target {
-            if snapshot.block_exists(&target.pack()) {
+            if snapshot.block_exists(&target.into()) {
                 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 1c5463b480..83f9b29af9 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.into()).build()
+            empty_output.as_builder().capacity(occupied).build()
         };
         let witness = Script::default().into_witness();
         let cellbase = TransactionBuilder::default()
             .input(input)
             .output(output)
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .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.into())
-            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).into())
+            .compact_target(DIFF_TWO)
+            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0))
             .dao(dao)
             .transaction(cellbase)
             .build();
diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index 2d54b047c3..588aa4657d 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -633,14 +633,14 @@ impl ChainSpec {
         );
 
         let block = BlockBuilder::default()
-            .version(self.genesis.version.into())
-            .parent_hash((&self.genesis.parent_hash).into())
-            .timestamp(self.genesis.timestamp.into())
-            .compact_target(self.genesis.compact_target.into())
-            .extra_hash((&self.genesis.uncles_hash).into())
-            .epoch(EpochNumberWithFraction::new_unchecked(0, 0, 0).into())
+            .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))
             .dao(dao)
-            .nonce(u128::from_le_bytes(self.genesis.nonce.to_le_bytes()).into())
+            .nonce(u128::from_le_bytes(self.genesis.nonce.to_le_bytes()))
             .transaction(cellbase_transaction)
             .transaction(dep_group_transaction)
             .build();
@@ -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())).into())
-            .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone().into())
-            .hash_type(ScriptHashType::Data.into())
+            .args(secp_lock_arg(&Privkey::from(SPECIAL_CELL_PRIVKEY.clone())))
+            .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone())
+            .hash_type(ScriptHashType::Data)
             .build();
         let special_issued_cell = packed::CellOutput::new_builder()
-            .capacity(special_cell_capacity.into())
+            .capacity(special_cell_capacity)
             .lock(special_issued_lock)
             .build();
         outputs.push(special_issued_cell);
@@ -874,7 +874,7 @@ impl ChainSpec {
 
                 let data = Into::<packed::OutPointVec>::into(out_points).as_bytes();
                 let cell = packed::CellOutput::new_builder()
-                    .lock(self.genesis.system_cells_lock.clone().into())
+                    .lock(self.genesis.system_cells_lock.clone())
                     .build_exact_capacity(Capacity::bytes(data.len())?)?;
                 Ok((cell, data.into()))
             })
@@ -918,7 +918,7 @@ impl ChainSpec {
         let tx_hash: H256 = tx.hash().into();
         let message = H256::from(blake2b_256(tx_hash));
         let sig = privkey.sign_recoverable(&message).expect("sign");
-        let witness = Bytes::from(sig.serialize()).into();
+        let witness = Bytes::from(sig.serialize());
 
         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().into())
+            .lock(self.lock.clone())
             .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().into())
-            .capacity(self.capacity.into())
+            .lock(self.lock.clone())
+            .capacity(self.capacity)
             .build()
     }
 }
@@ -963,12 +963,12 @@ impl SystemCell {
             None
         };
         let builder = packed::CellOutput::new_builder()
-            .type_(type_script.into())
-            .lock(lock.clone().into());
+            .type_(type_script)
+            .lock(lock.clone());
 
         let data_len = Capacity::bytes(data.len())?;
         let cell = if let Some(capacity) = self.capacity {
-            let cell = builder.capacity(capacity.into()).build();
+            let cell = builder.capacity(capacity).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.into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(script_arg.into())
+        .code_hash(TYPE_ID_CODE_HASH)
+        .hash_type(ScriptHashType::Type)
+        .args(script_arg)
         .build()
 }
 
diff --git a/spec/src/tests/consensus.rs b/spec/src/tests/consensus.rs
index d2fe44fe8e..4cbec57011 100644
--- a/spec/src/tests/consensus.rs
+++ b/spec/src/tests/consensus.rs
@@ -52,8 +52,8 @@ fn test_halving_epoch_reward() {
 
     let header = |epoch: &EpochExt, number: u64| {
         HeaderBuilder::default()
-            .number(number.into())
-            .epoch(epoch.number_with_fraction(number).into())
+            .number(number)
+            .epoch(epoch.number_with_fraction(number))
             .build()
     };
 
diff --git a/spec/src/tests/versionbits.rs b/spec/src/tests/versionbits.rs
index e4aa549b4d..898a17b97a 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).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .number(parent.number() + 1)
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
             .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().into())
+            .message(version.to_le_bytes().as_slice())
             .build();
 
-        let witness = cellbase_witness.as_bytes().into();
+        let witness = cellbase_witness.as_bytes();
         let cellbase = TransactionBuilder::default().witness(witness).build();
 
         BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .number(parent.number() + 1)
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
             .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).into())
+        .epoch(epoch_ext.number_with_fraction(0))
         .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).into())
+        .epoch(epoch_ext.number_with_fraction(0))
         .transaction(cellbase)
         .build();
 
diff --git a/store/src/cell.rs b/store/src/cell.rs
index d840668230..182fb06459 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.into())
+                        .index(index)
                         .build();
 
                     let entry = packed::CellEntryBuilder::default()
                         .output(cell_output)
                         .block_hash(block_hash.clone())
-                        .block_number(block_number.into())
-                        .block_epoch(block_epoch.into())
-                        .index(tx_index.into())
-                        .data_size((data.len() as u64).into())
+                        .block_number(block_number)
+                        .block_epoch(block_epoch)
+                        .index(tx_index)
+                        .data_size(data.len() as u64)
                         .build();
 
                     let data_entry = if !data.is_empty() {
                         let data_hash = packed::CellOutput::calc_data_hash(&data);
                         Some(
                             packed::CellDataEntryBuilder::default()
-                                .output_data(data.into())
+                                .output_data(data)
                                 .output_data_hash(data_hash)
                                 .build(),
                         )
@@ -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.into())
+                                .index(index)
                                 .build();
 
                             let entry = packed::CellEntryBuilder::default()
                                 .output(cell_output)
                                 .block_hash(block_hash.clone())
-                                .block_number(block_number.into())
-                                .block_epoch(block_epoch.into())
-                                .index(tx_index.into())
-                                .data_size((data.len() as u64).into())
+                                .block_number(block_number)
+                                .block_epoch(block_epoch)
+                                .index(tx_index)
+                                .data_size(data.len() as u64)
                                 .build();
 
                             let data_entry = if !data.is_empty() {
                                 let data_hash = packed::CellOutput::calc_data_hash(&data);
                                 Some(
                                     packed::CellDataEntryBuilder::default()
-                                        .output_data(data.into())
+                                        .output_data(data)
                                         .output_data_hash(data_hash)
                                         .build(),
                                 )
diff --git a/store/src/tests/db.rs b/store/src/tests/db.rs
index 39aff4e9a7..5372d0f27e 100644
--- a/store/src/tests/db.rs
+++ b/store/src/tests/db.rs
@@ -31,8 +31,7 @@ fn save_and_get_block_with_transactions() {
         .transactions(
             (0..3)
                 .map(|_| packed::Transaction::new_builder().build())
-                .collect::<Vec<_>>()
-                .into(),
+                .collect::<Vec<_>>(),
         )
         .build()
         .into_view();
@@ -98,7 +97,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.into()).build();
+    let raw = packed::RawHeader::new_builder().number(1u64).build();
     let block = packed::Block::new_builder()
         .header(packed::Header::new_builder().raw(raw).build())
         .build()
@@ -132,7 +131,7 @@ fn freeze_blockv1_with_extension() {
     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.into()).build();
+    let raw = packed::RawHeader::new_builder().number(1u64).build();
     let block = packed::BlockV1::new_builder()
         .header(packed::Header::new_builder().raw(raw).build())
         .extension(extension)
diff --git a/store/src/transaction.rs b/store/src/transaction.rs
index ea7506728e..51388d3091 100644
--- a/store/src/transaction.rs
+++ b/store/src/transaction.rs
@@ -189,7 +189,7 @@ impl StoreTransaction {
         self.insert_raw(
             COLUMN_NUMBER_HASH,
             packed::NumberHash::new_builder()
-                .number(block.number().into())
+                .number(block.number())
                 .block_hash(hash.clone())
                 .build()
                 .as_slice(),
@@ -203,7 +203,7 @@ impl StoreTransaction {
         for (index, tx) in block.transactions().into_iter().enumerate() {
             let key = packed::TransactionKey::new_builder()
                 .block_hash(hash.clone())
-                .index(index.into())
+                .index(index)
                 .build();
             let tx_data = Into::<packed::TransactionView>::into(tx);
             self.insert_raw(COLUMN_BLOCK_BODY, key.as_slice(), tx_data.as_slice())?;
@@ -222,7 +222,7 @@ impl StoreTransaction {
         self.delete(
             COLUMN_NUMBER_HASH,
             packed::NumberHash::new_builder()
-                .number(block.number().into())
+                .number(block.number())
                 .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.into())
+                .index(index)
                 .build();
             self.delete(COLUMN_BLOCK_BODY, key.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.into())
+                .index(index)
                 .build();
             let info = packed::TransactionInfo::new_builder()
                 .key(key)
diff --git a/store/src/write_batch.rs b/store/src/write_batch.rs
index 367b9bb165..a2568505d2 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.into())
+                .number(number)
                 .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.into())
+                .index(i)
                 .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 56ef4e08db..e7b36d58be 100644
--- a/sync/src/filter/get_block_filter_check_points_process.rs
+++ b/sync/src/filter/get_block_filter_check_points_process.rs
@@ -52,8 +52,8 @@ impl<'a> GetBlockFilterCheckPointsProcess<'a> {
                 }
             }
             let content = packed::BlockFilterCheckPoints::new_builder()
-                .start_number(start_number.into())
-                .block_filter_hashes(block_filter_hashes.into())
+                .start_number(start_number)
+                .block_filter_hashes(block_filter_hashes)
                 .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 25142bc2d6..3576ca0119 100644
--- a/sync/src/filter/get_block_filter_hashes_process.rs
+++ b/sync/src/filter/get_block_filter_hashes_process.rs
@@ -60,9 +60,9 @@ impl<'a> GetBlockFilterHashesProcess<'a> {
                 }
             }
             let content = packed::BlockFilterHashes::new_builder()
-                .start_number(start_number.into())
+                .start_number(start_number)
                 .parent_block_filter_hash(parent_block_filter_hash)
-                .block_filter_hashes(block_filter_hashes.into())
+                .block_filter_hashes(block_filter_hashes)
                 .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 8d8257a04b..e5e6f38d31 100644
--- a/sync/src/filter/get_block_filters_process.rs
+++ b/sync/src/filter/get_block_filters_process.rs
@@ -51,9 +51,9 @@ impl<'a> GetBlockFiltersProcess<'a> {
                 }
             }
             let content = packed::BlockFilters::new_builder()
-                .start_number(start_number.into())
-                .block_hashes(block_hashes.into())
-                .filters(filters.into())
+                .start_number(start_number)
+                .block_hashes(block_hashes)
+                .filters(filters)
                 .build();
 
             let message = packed::BlockFilterMessage::new_builder()
diff --git a/sync/src/net_time_checker.rs b/sync/src/net_time_checker.rs
index 3b7c2acc79..aa384f9151 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.into()).build();
+            let time = packed::Time::new_builder().timestamp(now).build();
             let _status = send_message_to(nc.as_ref(), peer_index, &time);
         }
     }
diff --git a/sync/src/relayer/block_transactions_process.rs b/sync/src/relayer/block_transactions_process.rs
index 6e380b1751..c2c10077a4 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().into())
-                    .uncle_indexes(missing_uncles.as_slice().into())
+                    .indexes(missing_transactions.as_slice())
+                    .uncle_indexes(missing_uncles.as_slice())
                     .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 483570f807..9ee0d40918 100644
--- a/sync/src/relayer/compact_block_process.rs
+++ b/sync/src/relayer/compact_block_process.rs
@@ -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().into())
-        .uncle_indexes(missing_uncles.as_slice().into())
+        .indexes(missing_transactions.as_slice())
+        .uncle_indexes(missing_uncles.as_slice())
         .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/get_block_proposal_process.rs b/sync/src/relayer/get_block_proposal_process.rs
index 052c684c37..59fd24189c 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.into())
+            .transactions(txs)
             .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 acb332993f..b6c249c2aa 100644
--- a/sync/src/relayer/get_block_transactions_process.rs
+++ b/sync/src/relayer/get_block_transactions_process.rs
@@ -84,15 +84,13 @@ impl<'a> GetBlockTransactionsProcess<'a> {
                     transactions
                         .into_iter()
                         .map(|tx| tx.data())
-                        .collect::<Vec<Transaction>>()
-                        .into(),
+                        .collect::<Vec<Transaction>>(),
                 )
                 .uncles(
                     uncles
                         .into_iter()
                         .map(|uncle| uncle.data())
-                        .collect::<Vec<UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<UncleBlock>>(),
                 )
                 .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 36370f22ae..766ff2af4d 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.into())
+                        .cycles(cycles)
                         .transaction(tx.data())
                         .build()
                 })
diff --git a/sync/src/relayer/mod.rs b/sync/src/relayer/mod.rs
index 9acd6ab82a..366bd8e292 100644
--- a/sync/src/relayer/mod.rs
+++ b/sync/src/relayer/mod.rs
@@ -272,7 +272,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().into())
+                .proposals(to_ask_proposals.clone())
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
             if !send_message_to(nc, peer, &message).is_ok() {
@@ -496,12 +496,11 @@ impl Relayer {
             let block = if let Some(extension) = compact_block.extension() {
                 packed::BlockV1::new_builder()
                     .header(compact_block.header())
-                    .uncles(uncles.into())
+                    .uncles(uncles)
                     .transactions(
                         txs.into_iter()
                             .map(|tx| tx.data())
-                            .collect::<Vec<Transaction>>()
-                            .into(),
+                            .collect::<Vec<Transaction>>(),
                     )
                     .proposals(compact_block.proposals())
                     .extension(extension)
@@ -510,12 +509,11 @@ impl Relayer {
             } else {
                 packed::Block::new_builder()
                     .header(compact_block.header())
-                    .uncles(uncles.into())
+                    .uncles(uncles)
                     .transactions(
                         txs.into_iter()
                             .map(|tx| tx.data())
-                            .collect::<Vec<Transaction>>()
-                            .into(),
+                            .collect::<Vec<Transaction>>(),
                     )
                     .proposals(compact_block.proposals())
                     .build()
@@ -604,7 +602,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.into())
+                    .transactions(txs)
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
                 let status = send_message_to(nc, peer_index, &message);
@@ -650,7 +648,7 @@ impl Relayer {
                 );
                 tx_hashes.truncate(MAX_RELAY_TXS_NUM_PER_BATCH);
                 let content = packed::GetRelayTransactions::new_builder()
-                    .tx_hashes(tx_hashes.into())
+                    .tx_hashes(tx_hashes)
                     .build();
                 let message = packed::RelayMessage::new_builder().set(content).build();
                 let status = send_message_to(nc, peer, &message);
@@ -732,7 +730,7 @@ impl Relayer {
         }
         for (peer, hashes) in selected {
             let content = packed::RelayTransactionHashes::new_builder()
-                .tx_hashes(hashes.into())
+                .tx_hashes(hashes)
                 .build();
             let message = packed::RelayMessage::new_builder().set(content).build();
 
@@ -801,7 +799,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(Pack::pack(&block.extension()))
+            .extension(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 bca97bcb0a..fb56fa01ce 100644
--- a/sync/src/relayer/tests/block_proposal_process.rs
+++ b/sync/src/relayer/tests/block_proposal_process.rs
@@ -20,8 +20,7 @@ fn test_no_unknown() {
             transactions
                 .into_iter()
                 .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>()
-                .into(),
+                .collect::<Vec<Transaction>>(),
         )
         .build();
 
@@ -41,8 +40,7 @@ fn test_no_asked() {
             transactions
                 .into_iter()
                 .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>()
-                .into(),
+                .collect::<Vec<Transaction>>(),
         )
         .build();
 
@@ -76,8 +74,7 @@ fn test_ok() {
             transactions
                 .into_iter()
                 .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>()
-                .into(),
+                .collect::<Vec<Transaction>>(),
         )
         .build();
 
@@ -111,8 +108,7 @@ fn test_clear_expired_inflight_proposals() {
             transactions
                 .into_iter()
                 .map(|tx| tx.data())
-                .collect::<Vec<Transaction>>()
-                .into(),
+                .collect::<Vec<Transaction>>(),
         )
         .build();
 
diff --git a/sync/src/relayer/tests/block_transactions_process.rs b/sync/src/relayer/tests/block_transactions_process.rs
index ad32e0c018..247baae90a 100644
--- a/sync/src/relayer/tests/block_transactions_process.rs
+++ b/sync/src/relayer/tests/block_transactions_process.rs
@@ -26,19 +26,19 @@ fn test_accept_block() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().into())
+                .capacity(Capacity::bytes(1).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let tx3 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap().into())
+                .capacity(Capacity::bytes(2).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
     let uncle = BlockBuilder::default()
         .proposals(Into::<packed::ProposalShortIdVec>::into(vec![
@@ -72,8 +72,8 @@ fn test_accept_block() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].into())
-        .uncles(vec![uncle.as_uncle().data()].into())
+        .transactions(vec![tx2.data()])
+        .uncles(vec![uncle.as_uncle().data()])
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -106,10 +106,10 @@ fn test_unknown_request() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().into())
+                .capacity(Capacity::bytes(1).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let block = BlockBuilder::default()
@@ -135,7 +135,7 @@ fn test_unknown_request() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].into())
+        .transactions(vec![tx2.data()])
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -159,14 +159,14 @@ fn test_invalid_transaction_root() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().into())
+                .capacity(Capacity::bytes(1).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let prefilled = IndexTransaction::new_builder()
-        .index(0u32.into())
+        .index(0u32)
         .transaction(tx1.data())
         .build();
 
@@ -180,8 +180,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()].into())
-        .prefilled_transactions(vec![prefilled].into())
+        .short_ids(vec![tx2.proposal_short_id()])
+        .prefilled_transactions(vec![prefilled])
         .build();
 
     let block_hash = compact_block.header().calc_header_hash();
@@ -200,7 +200,7 @@ fn test_invalid_transaction_root() {
 
     let block_transactions: BlockTransactions = packed::BlockTransactions::new_builder()
         .block_hash(block_hash)
-        .transactions(vec![tx2.data()].into())
+        .transactions(vec![tx2.data()])
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -236,28 +236,28 @@ fn test_collision_and_send_missing_indexes() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1000).unwrap().into())
+                .capacity(Capacity::bytes(1000).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
     let tx3 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(last_cellbase.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap().into())
+                .capacity(Capacity::bytes(2).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let fake_hash = tx3
         .hash()
         .as_builder()
-        .nth31(0u8.into())
-        .nth30(0u8.into())
-        .nth29(0u8.into())
-        .nth28(0u8.into())
+        .nth31(0u8)
+        .nth30(0u8)
+        .nth29(0u8)
+        .nth28(0u8)
         .build();
     // Fake tx with the same ProposalShortId but different hash with tx3
     let fake_tx = tx3.clone().fake_hash(fake_hash);
@@ -296,7 +296,7 @@ fn test_collision_and_send_missing_indexes() {
 
     let block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].into())
+        .transactions(vec![tx2.data()])
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -315,7 +315,7 @@ fn test_collision_and_send_missing_indexes() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1u32, 2u32].into())
+        .indexes([1u32, 2u32])
         .build();
     let message = packed::RelayMessage::new_builder().set(content).build();
     let data = message.as_bytes();
@@ -339,7 +339,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()].into())
+        .transactions(vec![tx2.data(), tx3.data()])
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -372,18 +372,18 @@ fn test_missing() {
     let tx2 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(1).unwrap().into())
+                .capacity(Capacity::bytes(1).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
     let tx3 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(Capacity::bytes(2).unwrap().into())
+                .capacity(Capacity::bytes(2).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let block = BlockBuilder::default()
@@ -410,7 +410,7 @@ fn test_missing() {
 
     let block_transactions = packed::BlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .transactions(vec![tx2.data()].into())
+        .transactions(vec![tx2.data()])
         .build();
 
     let mock_protocol_context = MockProtocolContext::new(SupportProtocols::RelayV2);
@@ -429,7 +429,7 @@ fn test_missing() {
 
     let content = packed::GetBlockTransactions::new_builder()
         .block_hash(block.header().hash())
-        .indexes([1, 2u32].into())
+        .indexes([1, 2u32])
         .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 485fe1573a..6934c1f5af 100644
--- a/sync/src/relayer/tests/block_transactions_verifier.rs
+++ b/sync/src/relayer/tests/block_transactions_verifier.rs
@@ -18,8 +18,8 @@ fn build_compact_block() -> CompactBlock {
         .collect::<Vec<packed::ProposalShortId>>();
 
     CompactBlockBuilder::default()
-        .short_ids(short_ids.into())
-        .prefilled_transactions(prefilled_iter.into())
+        .short_ids(short_ids)
+        .prefilled_transactions(prefilled_iter)
         .build()
 }
 
diff --git a/sync/src/relayer/tests/compact_block.rs b/sync/src/relayer/tests/compact_block.rs
index 92ecaadb50..72b6169a81 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.into())
+            .index(0u32)
             .transaction(TransactionBuilder::default().build().data())
             .build(),
         IndexTransactionBuilder::default()
-            .index(2u32.into())
+            .index(2u32)
             .transaction(TransactionBuilder::default().build().data())
             .build(),
     ];
 
     let compact_block = compact_block_builder
-        .short_ids(short_ids.into())
-        .prefilled_transactions(prefilled_transactions.into())
+        .short_ids(short_ids)
+        .prefilled_transactions(prefilled_transactions)
         .build();
 
     assert_eq!(
diff --git a/sync/src/relayer/tests/compact_block_process.rs b/sync/src/relayer/tests/compact_block_process.rs
index fca2194039..1948a47e81 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.into())
-                .epoch(EpochNumberWithFraction::new(1, 5, 1000).into())
-                .timestamp(unix_time_as_millis().into())
+                .number(5)
+                .epoch(EpochNumberWithFraction::new(1, 5, 1000))
+                .timestamp(unix_time_as_millis())
                 .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.into())
+        .block_locator_hashes(locator_hash)
         .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.into())
+        .number(4)
         .build();
 
     let block = BlockBuilder::default()
@@ -285,10 +285,10 @@ fn test_send_missing_indexes() {
             TransactionBuilder::default()
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(Capacity::bytes(1).unwrap().into())
+                        .capacity(Capacity::bytes(1).unwrap())
                         .build(),
                 )
-                .output_data(Bytes::new().into())
+                .output_data(Bytes::new())
                 .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].into())
-        .uncle_indexes([0u32].into())
+        .indexes([1u32])
+        .uncle_indexes([0u32])
         .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].into())
+        .proposals(vec![proposal_id])
         .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.into())
-        .epoch(EpochNumberWithFraction::new(1, 4, 1000).into())
+        .number(4)
+        .epoch(EpochNumberWithFraction::new(1, 4, 1000))
         .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.into()).build();
+    let mock_block_2 = block.as_advanced_builder().number(7).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().into())
+                .capacity(Capacity::bytes(1000).unwrap())
                 .build(),
         )
         .input(CellInput::new(OutPoint::new(last_cellbase.hash(), 0), 0))
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     let fake_hash = missing_tx
         .hash()
         .as_builder()
-        .nth31(0u8.into())
-        .nth30(0u8.into())
-        .nth29(0u8.into())
-        .nth28(0u8.into())
+        .nth31(0u8)
+        .nth30(0u8)
+        .nth29(0u8)
+        .nth28(0u8)
         .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].into())
+        .indexes([1u32])
         .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 4c0b9e686d..e85da0c024 100644
--- a/sync/src/relayer/tests/compact_block_verifier.rs
+++ b/sync/src/relayer/tests/compact_block_verifier.rs
@@ -11,7 +11,7 @@ fn test_unordered_prefilled() {
         .map(new_index_transaction)
         .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.into())
+        .prefilled_transactions(prefilled)
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -25,7 +25,7 @@ fn test_ordered_prefilled() {
         .map(new_index_transaction)
         .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.into())
+        .prefilled_transactions(prefilled)
         .build();
     assert_eq!(PrefilledVerifier::verify(&block), Status::ok());
 }
@@ -37,7 +37,7 @@ fn test_overflow_prefilled() {
         .map(new_index_transaction)
         .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.into())
+        .prefilled_transactions(prefilled)
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -57,7 +57,7 @@ fn test_cellbase_not_prefilled() {
         .map(new_index_transaction)
         .collect::<Vec<packed::IndexTransaction>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.into())
+        .prefilled_transactions(prefilled)
         .build();
     assert_eq!(
         PrefilledVerifier::verify(&block),
@@ -72,9 +72,7 @@ fn test_duplicated_short_ids() {
         .collect();
     short_ids.push(short_ids[0].clone());
 
-    let block = CompactBlockBuilder::default()
-        .short_ids(short_ids.into())
-        .build();
+    let block = CompactBlockBuilder::default().short_ids(short_ids).build();
     assert_eq!(
         ShortIdsVerifier::verify(&block),
         StatusCode::CompactBlockHasDuplicatedShortIds.into(),
@@ -91,8 +89,8 @@ fn test_intersected_short_ids() {
         .collect::<Vec<packed::ProposalShortId>>();
 
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.into())
-        .short_ids(short_ids.into())
+        .prefilled_transactions(prefilled)
+        .short_ids(short_ids)
         .build();
     assert_eq!(
         ShortIdsVerifier::verify(&block),
@@ -111,8 +109,8 @@ fn test_normal() {
         .map(|i| new_index_transaction(i).transaction().proposal_short_id())
         .collect::<Vec<packed::ProposalShortId>>();
     let block = CompactBlockBuilder::default()
-        .prefilled_transactions(prefilled.into())
-        .short_ids(short_ids.into())
+        .prefilled_transactions(prefilled)
+        .short_ids(short_ids)
         .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 55a9adda42..f38308dc06 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].into())
+        .proposals(vec![id.clone(), id])
         .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 9b206cdd50..6839daf7bb 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].into())
+        .tx_hashes(vec![tx_hash.clone(), tx_hash])
         .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 6f7e562959..72d85709cd 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().into())
+                .capacity(Capacity::bytes(index).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
 
     IndexTransactionBuilder::default()
-        .index(index.into())
+        .index(index)
         .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).into())
-        .timestamp((parent.timestamp() + 1).into())
-        .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-        .compact_target(epoch.compact_target().into())
+        .number(parent.number() + 1)
+        .timestamp(parent.timestamp() + 1)
+        .epoch(epoch.number_with_fraction(parent.number() + 1))
+        .compact_target(epoch.compact_target())
 }
 
 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().into()) // use capacity to identify transactions
+                .capacity(Capacity::bytes(500 + index).unwrap() ) // use capacity to identify transactions
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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.into())
+        .output_data(always_success_cell_data)
         .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().into())
+            .timestamp(unix_time_as_millis())
             .dao(dao)
-            .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+            .compact_target(difficulty_to_compact(U256::from(1000u64)))
             .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).into())
+                    .capacity(capacity_bytes!(50000))
                     .lock(always_success_script.to_owned())
                     .build(),
             )
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .witness(Script::default().into_witness())
             .build();
         let header = new_header_builder(&shared, &parent.header()).build();
@@ -273,22 +273,20 @@ 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())
-            .into(),
+                .unwrap(),
         )
-        .number(number.into())
+        .number(number)
         .compact_target(
-            (epoch
+            epoch
                 .compact_target()
                 .checked_add_signed(target_delta)
-                .unwrap())
-            .into(),
+                .unwrap(),
         )
         .dao(dao)
-        .epoch(epoch.number_with_fraction(number).into())
+        .epoch(epoch.number_with_fraction(number))
         .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 303e48db32..167356b822 100644
--- a/sync/src/relayer/tests/reconstruct_block.rs
+++ b/sync/src/relayer/tests/reconstruct_block.rs
@@ -25,7 +25,7 @@ fn test_missing_txs() {
             .map(|tx| tx.proposal_short_id())
             .collect::<Vec<packed::ProposalShortId>>();
         let transactions: Vec<TransactionView> = prepare.iter().skip(1).cloned().collect();
-        let compact = compact_block_builder.short_ids(short_ids.into()).build();
+        let compact = compact_block_builder.short_ids(short_ids).build();
         assert_eq!(
             relayer.reconstruct_block(
                 &relayer.shared().active_chain(),
@@ -53,7 +53,7 @@ fn test_missing_txs() {
             .step_by(2)
             .map(|(i, _)| i)
             .collect();
-        let compact = compact_block_builder.short_ids(short_ids.into()).build();
+        let compact = compact_block_builder.short_ids(short_ids).build();
         assert_eq!(
             relayer.reconstruct_block(
                 &relayer.shared().active_chain(),
@@ -110,7 +110,7 @@ fn test_reconstruct_transactions_and_uncles() {
 
     // BLOCK_VALID
     let ext = packed::BlockExtBuilder::default()
-        .verified(Some(true).into())
+        .verified(Some(true))
         .build();
 
     let compact = packed::CompactBlock::build_from_block(&block, &prefilled);
@@ -155,7 +155,7 @@ fn test_reconstruct_invalid_uncles() {
     let uncle = BlockBuilder::default().build();
     // BLOCK_VALID
     let ext = packed::BlockExtBuilder::default()
-        .verified(Some(false).into())
+        .verified(Some(false))
         .build();
 
     let block = BlockBuilder::default()
diff --git a/sync/src/synchronizer/get_headers_process.rs b/sync/src/synchronizer/get_headers_process.rs
index cbb0738252..d5e8d7e4d7 100644
--- a/sync/src/synchronizer/get_headers_process.rs
+++ b/sync/src/synchronizer/get_headers_process.rs
@@ -85,8 +85,7 @@ impl<'a> GetHeadersProcess<'a> {
                     headers
                         .into_iter()
                         .map(|x| x.data())
-                        .collect::<Vec<packed::Header>>()
-                        .into(),
+                        .collect::<Vec<packed::Header>>(),
                 )
                 .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 8a18cc6973..fe1bee8004 100644
--- a/sync/src/synchronizer/mod.rs
+++ b/sync/src/synchronizer/mod.rs
@@ -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().into())
+            .block_hashes(v_fetch.clone())
             .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().into())
+            .block_hashes(v_fetch.clone())
             .build();
         let message = packed::SyncMessage::new_builder().set(content).build();
 
diff --git a/sync/src/tests/orphan_block_pool.rs b/sync/src/tests/orphan_block_pool.rs
deleted file mode 100644
index c761ce89b1..0000000000
--- a/sync/src/tests/orphan_block_pool.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use ckb_chain_spec::consensus::ConsensusBuilder;
-use ckb_systemtime::unix_time_as_millis;
-use ckb_types::core::{BlockBuilder, BlockView, EpochNumberWithFraction, HeaderView};
-use std::collections::HashSet;
-use std::sync::Arc;
-use std::thread;
-
-use crate::orphan_block_pool::OrphanBlockPool;
-
-fn gen_block(parent_header: &HeaderView) -> BlockView {
-    let number = parent_header.number() + 1;
-    BlockBuilder::default()
-        .parent_hash(parent_header.hash())
-        .timestamp(unix_time_as_millis().into())
-        .number(number.into())
-        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
-        .nonce((parent_header.nonce() + 1).into())
-        .build()
-}
-
-#[test]
-fn test_remove_blocks_by_parent() {
-    let consensus = ConsensusBuilder::default().build();
-    let block_number = 200;
-    let mut blocks = Vec::new();
-    let mut parent = consensus.genesis_block().header();
-    let pool = OrphanBlockPool::with_capacity(200);
-    let mut total_size = 0;
-    for _ in 1..block_number {
-        let new_block = gen_block(&parent);
-        total_size += new_block.data().total_size();
-        blocks.push(new_block.clone());
-        pool.insert(new_block.clone());
-        parent = new_block.header();
-    }
-    assert_eq!(total_size, pool.total_size());
-
-    let orphan = pool.remove_blocks_by_parent(&consensus.genesis_block().hash());
-    let orphan_set: HashSet<BlockView> = orphan.into_iter().collect();
-    let blocks_set: HashSet<BlockView> = blocks.into_iter().collect();
-    assert_eq!(orphan_set, blocks_set);
-    assert_eq!(0, pool.total_size());
-}
-
-#[test]
-fn test_remove_blocks_by_parent_and_get_block_should_not_deadlock() {
-    let consensus = ConsensusBuilder::default().build();
-    let pool = OrphanBlockPool::with_capacity(1024);
-    let mut header = consensus.genesis_block().header();
-    let mut hashes = Vec::new();
-    for _ in 1..1024 {
-        let new_block = gen_block(&header);
-        pool.insert(new_block.clone());
-        header = new_block.header();
-        hashes.push(header.hash());
-    }
-
-    let pool_arc1 = Arc::new(pool);
-    let pool_arc2 = Arc::clone(&pool_arc1);
-
-    let thread1 = thread::spawn(move || {
-        pool_arc1.remove_blocks_by_parent(&consensus.genesis_block().hash());
-    });
-
-    for hash in hashes.iter().rev() {
-        pool_arc2.get_block(hash);
-    }
-
-    thread1.join().unwrap();
-}
-
-#[test]
-fn test_leaders() {
-    let consensus = ConsensusBuilder::default().build();
-    let block_number = 20;
-    let mut blocks = Vec::new();
-    let mut parent = consensus.genesis_block().header();
-    let pool = OrphanBlockPool::with_capacity(20);
-    for i in 0..block_number - 1 {
-        let new_block = gen_block(&parent);
-        blocks.push(new_block.clone());
-        parent = new_block.header();
-        if i % 5 != 0 {
-            pool.insert(new_block.clone());
-        }
-    }
-
-    assert_eq!(pool.len(), 15);
-    assert_eq!(pool.leaders_len(), 4);
-
-    pool.insert(blocks[5].clone());
-    assert_eq!(pool.len(), 16);
-    assert_eq!(pool.leaders_len(), 3);
-
-    pool.insert(blocks[10].clone());
-    assert_eq!(pool.len(), 17);
-    assert_eq!(pool.leaders_len(), 2);
-
-    // index 0 doesn't in the orphan pool, so do nothing
-    let orphan = pool.remove_blocks_by_parent(&consensus.genesis_block().hash());
-    assert!(orphan.is_empty());
-    assert_eq!(pool.len(), 17);
-    assert_eq!(pool.leaders_len(), 2);
-
-    pool.insert(blocks[0].clone());
-    assert_eq!(pool.len(), 18);
-    assert_eq!(pool.leaders_len(), 2);
-
-    let orphan = pool.remove_blocks_by_parent(&consensus.genesis_block().hash());
-    assert_eq!(pool.len(), 3);
-    assert_eq!(pool.leaders_len(), 1);
-
-    pool.insert(blocks[15].clone());
-    assert_eq!(pool.len(), 4);
-    assert_eq!(pool.leaders_len(), 1);
-
-    let orphan_1 = pool.remove_blocks_by_parent(&blocks[14].hash());
-
-    let orphan_set: HashSet<BlockView> = orphan.into_iter().chain(orphan_1).collect();
-    let blocks_set: HashSet<BlockView> = blocks.into_iter().collect();
-    assert_eq!(orphan_set, blocks_set);
-    assert_eq!(pool.len(), 0);
-    assert_eq!(pool.leaders_len(), 0);
-}
-
-#[test]
-fn test_remove_expired_blocks() {
-    let consensus = ConsensusBuilder::default().build();
-    let block_number = 20;
-    let mut parent = consensus.genesis_block().header();
-    let pool = OrphanBlockPool::with_capacity(block_number);
-
-    let deprecated = EpochNumberWithFraction::new(10, 0, 10);
-
-    for _ in 1..block_number {
-        let new_block = BlockBuilder::default()
-            .parent_hash(parent.hash())
-            .timestamp(unix_time_as_millis().into())
-            .number((parent.number() + 1).into())
-            .epoch(deprecated.into())
-            .nonce((parent.nonce() + 1).into())
-            .build();
-        pool.insert(new_block.clone());
-        parent = new_block.header();
-    }
-    assert_eq!(pool.leaders_len(), 1);
-
-    let v = pool.clean_expired_blocks(20_u64);
-    assert_eq!(v.len(), 19);
-    assert_eq!(pool.leaders_len(), 0);
-    assert_eq!(pool.total_size(), 0)
-}
diff --git a/sync/src/tests/sync_shared.rs b/sync/src/tests/sync_shared.rs
index 5e3826e8b5..6219bc3eb5 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.into())
+            .number(1000)
             .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).into())
+            .timestamp(parent_header.timestamp() + 3)
             .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).into())
+            .timestamp(parent_header.timestamp() + 3)
             .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([new_block.header()].map(|x| x.data()).pack())
+        .headers(vec![new_block.header().data()])
         .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.pack())
+            .timestamp(next_timestamp)
             .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([new_block.header()].map(|x| x.data()).pack())
+        .headers(vec![new_block.header().data()])
         .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 188f2198cd..4337fb5312 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.into())
+        .output_data(always_success_cell_data)
         .build();
 
     let dao = genesis_dao_data(vec![&always_success_tx]).unwrap();
 
     let mut block = BlockBuilder::default()
-        .timestamp(unix_time_as_millis().into())
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+        .timestamp(unix_time_as_millis())
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .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.into())
+                        .capacity(reward.total)
                         .lock(always_success_script.to_owned())
                         .build(),
                 )
-                .output_data(Bytes::default().into())
+                .output_data(Bytes::default())
                 .build()
         };
 
@@ -181,10 +181,10 @@ fn setup_node(height: u64) -> (TestNode, Shared) {
         block = BlockBuilder::default()
             .transaction(cellbase)
             .parent_hash(block.header().hash())
-            .number(number.into())
-            .epoch(epoch.number_with_fraction(number).into())
-            .timestamp(timestamp.into())
-            .compact_target(epoch.compact_target().into())
+            .number(number)
+            .epoch(epoch.number_with_fraction(number))
+            .timestamp(timestamp)
+            .compact_target(epoch.compact_target())
             .dao(dao)
             .extension(Some(bytes))
             .build();
diff --git a/sync/src/tests/synchronizer/functions.rs b/sync/src/tests/synchronizer/functions.rs
index 316d6a9c56..45892f1663 100644
--- a/sync/src/tests/synchronizer/functions.rs
+++ b/sync/src/tests/synchronizer/functions.rs
@@ -81,12 +81,8 @@ fn create_cellbase(
         builder.build()
     } else {
         builder
-            .output(
-                CellOutputBuilder::default()
-                    .capacity(reward.total.into())
-                    .build(),
-            )
-            .output_data(Bytes::new().into())
+            .output(CellOutputBuilder::default().capacity(reward.total).build())
+            .output_data(Bytes::new())
             .build()
     }
 }
@@ -119,11 +115,11 @@ fn gen_block(
     BlockBuilder::default()
         .transaction(cellbase)
         .parent_hash(parent_header.hash())
-        .timestamp(now.into())
-        .epoch(epoch.number_with_fraction(number).into())
-        .number(number.into())
-        .compact_target(epoch.compact_target().into())
-        .nonce(nonce.into())
+        .timestamp(now)
+        .epoch(epoch.number_with_fraction(number))
+        .number(number)
+        .compact_target(epoch.compact_target())
+        .nonce(nonce)
         .dao(dao)
         .extension(Some(bytes))
         .build()
@@ -634,8 +630,7 @@ fn test_sync_process() {
             headers
                 .iter()
                 .map(|h| h.data())
-                .collect::<Vec<packed::Header>>()
-                .into(),
+                .collect::<Vec<packed::Header>>(),
         )
         .build();
 
@@ -699,8 +694,7 @@ fn test_sync_process() {
             headers
                 .iter()
                 .map(|h| h.data())
-                .collect::<Vec<packed::Header>>()
-                .into(),
+                .collect::<Vec<packed::Header>>(),
         )
         .build();
     assert_eq!(
@@ -778,7 +772,7 @@ fn test_chain_sync_timeout() {
 
     let consensus = Consensus::default();
     let block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(3u64)).into())
+        .compact_target(difficulty_to_compact(U256::from(3u64)))
         .transaction(consensus.genesis_block().transactions()[0].clone())
         .build();
     let consensus = ConsensusBuilder::default().genesis_block(block).build();
@@ -975,7 +969,7 @@ fn test_n_sync_started() {
 
     let consensus = Consensus::default();
     let block = BlockBuilder::default()
-        .compact_target(difficulty_to_compact(U256::from(3u64)).into())
+        .compact_target(difficulty_to_compact(U256::from(3u64)))
         .transaction(consensus.genesis_block().transactions()[0].clone())
         .build();
     let consensus = ConsensusBuilder::default().genesis_block(block).build();
@@ -1122,9 +1116,7 @@ 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.into())
-            .build();
+        let sendheaders = SendHeadersBuilder::default().headers(fork_headers).build();
         synchronizer.on_connected(&nc, peer);
         assert!(
             HeadersProcess::new(sendheaders.as_reader(), &synchronizer, peer, &nc)
@@ -1199,7 +1191,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].into())
+        .block_hashes(vec![genesis_hash])
         .build();
 
     let nc = mock_network_context(1);
@@ -1212,7 +1204,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].into())
+        .block_hashes(vec![hash.clone(), hash])
         .build();
 
     let nc = mock_network_context(1);
diff --git a/sync/src/tests/types.rs b/sync/src/tests/types.rs
index 4fc1a2b657..83d23cc69e 100644
--- a/sync/src/tests/types.rs
+++ b/sync/src/tests/types.rs
@@ -24,9 +24,14 @@ 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.into())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into());
+        let mut header_builder =
+            HeaderBuilder::default()
+                .number(number)
+                .epoch(EpochNumberWithFraction::new(
+                    number / 1000,
+                    number % 1000,
+                    1000,
+                ));
         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 d59f9d4db9..4a314a3832 100644
--- a/sync/src/tests/util.rs
+++ b/sync/src/tests/util.rs
@@ -75,10 +75,10 @@ pub fn inherit_block(shared: &Shared, parent_hash: &Byte32) -> BlockBuilder {
 
     BlockBuilder::default()
         .parent_hash(parent_hash.to_owned())
-        .number((parent.header().number() + 1).into())
-        .timestamp((parent.header().timestamp() + 1).into())
-        .epoch(epoch.number_with_fraction(parent_number + 1).into())
-        .compact_target(epoch.compact_target().into())
+        .number(parent.header().number() + 1)
+        .timestamp(parent.header().timestamp() + 1)
+        .epoch(epoch.number_with_fraction(parent_number + 1))
+        .compact_target(epoch.compact_target())
         .dao(dao)
         .transaction(cellbase)
         .extension(Some(bytes))
diff --git a/sync/src/types/mod.rs b/sync/src/types/mod.rs
index 35fb940288..873882efc9 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.into())
+            .block_locator_hashes(locator_hash)
             .hash_stop(packed::Byte32::zero())
             .build();
         let message = packed::SyncMessage::new_builder().set(content).build();
diff --git a/test/src/node.rs b/test/src/node.rs
index f07668c811..1931666e95 100644
--- a/test/src/node.rs
+++ b/test/src/node.rs
@@ -19,7 +19,9 @@ use ckb_types::{
         self, capacity_bytes, BlockBuilder, BlockNumber, BlockView, Capacity, HeaderView,
         ScriptHashType, TransactionView,
     },
-    packed::{Block, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, Script},
+    packed::{
+        self, Block, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, Script,
+    },
     prelude::*,
 };
 use std::borrow::{Borrow, BorrowMut};
@@ -237,7 +239,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.into())
+            .hash_type(ScriptHashType::Data)
             .build()
     }
 
@@ -263,7 +265,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.into())
+            .hash_type(ScriptHashType::Data)
             .build()
     }
 
@@ -366,10 +368,7 @@ 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).into())
-            .build();
+        let uncle = block.as_advanced_builder().timestamp(timestamp + 1).build();
         (block, uncle)
     }
 
@@ -596,11 +595,11 @@ impl Node {
             .cell_dep(always_success_cell_dep)
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity.into())
+                    .capacity(capacity)
                     .lock(always_success_script)
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .input(CellInput::new(OutPoint::new(hash, index), since))
             .build()
     }
@@ -622,11 +621,11 @@ impl Node {
             .cell_dep(always_failure_cell_dep)
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(100).into())
+                    .capacity(capacity_bytes!(100))
                     .lock(always_failure_script)
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .input(CellInput::new(OutPoint::new(hash, 0), 0))
             .build()
     }
diff --git a/test/src/specs/alert/alert_propagation.rs b/test/src/specs/alert/alert_propagation.rs
index 027cfd9574..3af797ecd1 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.into())
-            .message((&warning1).into())
-            .notice_until(notice_until.into())
+            .id(id1)
+            .message(&warning1)
+            .notice_until(notice_until)
             .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.into())
-            .cancel(id1.into())
-            .message((&warning2).into())
-            .notice_until(notice_until.into())
+            .id(id2)
+            .cancel(id1)
+            .message(&warning2)
+            .notice_until(notice_until)
             .build();
         let alert2 = create_alert(raw_alert2, &self.privkeys);
         node0.rpc_client().send_alert(alert2.into());
@@ -156,6 +156,6 @@ fn create_alert(raw_alert: RawAlert, privkeys: &[Privkey]) -> Alert {
         .collect::<Vec<packed::Bytes>>();
     Alert::new_builder()
         .raw(raw_alert)
-        .signatures(signatures.into())
+        .signatures(signatures)
         .build()
 }
diff --git a/test/src/specs/consensus/insufficient_reward.rs b/test/src/specs/consensus/insufficient_reward.rs
index 0c0c9042b5..831759eccd 100644
--- a/test/src/specs/consensus/insufficient_reward.rs
+++ b/test/src/specs/consensus/insufficient_reward.rs
@@ -2,6 +2,7 @@ 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,
@@ -46,8 +47,8 @@ impl Spec for InsufficientReward {
 
         // build a block with insufficient reward
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(1).into())
-            .lock(Default::default())
+            .capacity(capacity_bytes!(1))
+            .lock(Script::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 9bed9be765..af9f4f8db5 100644
--- a/test/src/specs/dao/dao_tx.rs
+++ b/test/src/specs/dao/dao_tx.rs
@@ -61,10 +61,7 @@ impl Spec for WithdrawDAOWithOverflowCapacity {
                 .map(|cell_output| {
                     let old_capacity: Capacity = cell_output.capacity().into();
                     let new_capacity = old_capacity.safe_add(Capacity::one()).unwrap();
-                    cell_output
-                        .as_builder()
-                        .capacity(new_capacity.into())
-                        .build()
+                    cell_output.as_builder().capacity(new_capacity).build()
                 })
                 .collect();
             withdrawal
diff --git a/test/src/specs/dao/dao_user.rs b/test/src/specs/dao/dao_user.rs
index 4f9587c16a..b54fd1c7d9 100644
--- a/test/src/specs/dao/dao_user.rs
+++ b/test/src/specs/dao/dao_user.rs
@@ -51,9 +51,9 @@ impl<'a> DAOUser<'a> {
             (0..outputs_len)
                 .map(|_| {
                     CellOutput::new_builder()
-                        .capacity(capacity.into())
+                        .capacity(capacity)
                         .lock(node.always_success_script())
-                        .type_(Some(self.dao_type_script()).into())
+                        .type_(Some(self.dao_type_script()))
                         .build()
                 })
                 .collect::<Vec<_>>()
@@ -68,7 +68,7 @@ impl<'a> DAOUser<'a> {
             .inputs(inputs)
             .outputs(outputs)
             .outputs_data(outputs_data)
-            .witness(Default::default())
+            .witness(packed::Bytes::default())
             .build();
         self.deposit_utxo = TXOSet::from(&tx);
         tx
@@ -83,7 +83,7 @@ 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().into())
+                .capacity(txo.capacity())
                 .lock(txo.lock())
                 .type_(txo.type_())
                 .build()
@@ -108,7 +108,7 @@ 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())).into())
+                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())))
                     .build()
                     .as_bytes()
                     .into()
@@ -148,7 +148,7 @@ impl<'a> DAOUser<'a> {
             })
             .sum::<u64>();
         let output = CellOutput::new_builder()
-            .capacity(output_capacity.into())
+            .capacity(output_capacity)
             .lock(node.always_success_script())
             .build();
         let cell_deps = vec![node.always_success_cell_dep(), self.dao_cell_dep()];
@@ -167,7 +167,7 @@ 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())).into())
+                    .input_type(Some(Bytes::from(index.to_le_bytes().to_vec())))
                     .build()
                     .as_bytes()
                     .into()
@@ -179,7 +179,7 @@ impl<'a> DAOUser<'a> {
             .cell_deps(cell_deps)
             .header_deps(header_deps)
             .witnesses(witnesses)
-            .output_data(Default::default())
+            .output_data(packed::Bytes::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.into())
+            .hash_type(ScriptHashType::Type)
             .build()
     }
 
diff --git a/test/src/specs/dao/satoshi_dao_occupied.rs b/test/src/specs/dao/satoshi_dao_occupied.rs
index 6fb8965cea..74ae15a3cc 100644
--- a/test/src/specs/dao/satoshi_dao_occupied.rs
+++ b/test/src/specs/dao/satoshi_dao_occupied.rs
@@ -95,7 +95,7 @@ impl Spec for SpendSatoshiCell {
             0,
         );
         let output = CellOutput::new_builder()
-            .capacity(satoshi_cell_occupied.into())
+            .capacity(satoshi_cell_occupied)
             .lock(always_success_cell().2.clone())
             .build();
 
@@ -103,7 +103,7 @@ impl Spec for SpendSatoshiCell {
             .cell_deps(vec![node0.always_success_cell_dep()])
             .input(satoshi_input)
             .output(output)
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .build();
         let tx_hash = transaction.hash();
         let sig = self
@@ -113,10 +113,7 @@ impl Spec for SpendSatoshiCell {
         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.into())
-            .build();
+        let transaction = transaction.as_advanced_builder().witness(witness).build();
 
         node0.mine(1);
         node0
@@ -152,7 +149,7 @@ fn issue_satoshi_cell() -> IssuedCell {
         .2
         .clone()
         .as_builder()
-        .args(Bytes::from(&SATOSHI_PUBKEY_HASH.0[..]).into())
+        .args(Bytes::from(&SATOSHI_PUBKEY_HASH.0[..]))
         .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 801c12650c..c6f66e9f71 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.into())
+            .push(id)
             .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.into())
+            .dep_type(core::DepType::Code)
             .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).into())
+            .type_(Some(type_script))
             .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.into())
+            .hash_type(hash_type)
             .build()
     }
 
     fn as_type_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(core::ScriptHashType::Type.into())
+            .hash_type(core::ScriptHashType::Type)
             .build()
     }
 }
@@ -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)).into())
+            .type_(Some(type_script.as_data_script(0)))
             .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.into())
+            .dep_type(core::DepType::Code)
             .build()
     }
 
@@ -489,7 +489,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.into())
+            .dep_type(core::DepType::DepGroup)
             .build()
     }
 }
@@ -526,7 +526,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().into())
+            .capacity(input_cell.capacity.value())
             .lock(new_script.as_data_script(0))
             .build();
         let tx = TransactionView::new_advanced_builder()
@@ -534,7 +534,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
             .cell_dep(new_script.cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -546,16 +546,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().into())
+            .capacity(input_cell.capacity.value())
             .lock(self.node.always_success_script())
-            .type_(Some(new_script.as_data_script(0)).into())
+            .type_(Some(new_script.as_data_script(0)))
             .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(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -567,7 +567,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().into())
+            .capacity(input_cell.capacity.value())
             .lock(new_script.as_type_script())
             .build();
         let tx = TransactionView::new_advanced_builder()
@@ -575,7 +575,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
             .cell_dep(new_script.cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -587,16 +587,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().into())
+            .capacity(input_cell.capacity.value())
             .lock(self.node.always_success_script())
-            .type_(Some(new_script.as_type_script()).into())
+            .type_(Some(new_script.as_type_script()))
             .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(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         self.create_initial_input(tx)
     }
@@ -627,11 +627,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)).into()),
+                        .type_(Some(new_script.as_data_script(0))),
                     (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()).into()),
+                        .type_(Some(new_script.as_type_script())),
                 }
             }
         }
@@ -700,7 +700,7 @@ impl<'a> CheckCellDepsTestRunner<'a> {
         }
         .input(cell_input)
         .output(cell_output)
-        .output_data(Default::default())
+        .output_data(packed::Bytes::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 d03ac41f50..8c89d1d260 100644
--- a/test/src/specs/hardfork/v2021/vm_b_extension.rs
+++ b/test/src/specs/hardfork/v2021/vm_b_extension.rs
@@ -84,7 +84,7 @@ impl BExtScript {
         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.into())
+            .dep_type(DepType::Code)
             .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).into())
+            .type_(Some(type_script))
             .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.into())
+            .hash_type(hash_type)
             .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.into())
+            .hash_type(ScriptHashType::Type)
             .args(args)
             .build()
     }
@@ -225,7 +225,7 @@ impl<'a> CheckVmBExtensionTestRunner<'a> {
             let script = self.script.as_script(vm_opt, args);
             packed::CellOutput::new_builder()
                 .lock(self.node.always_success_script())
-                .type_(Some(script).into())
+                .type_(Some(script))
                 .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(Default::default())
+            .output_data(packed::Bytes::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 53911c67a6..e4f935d168 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.into())
+            .push(id)
             .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.into())
+            .dep_type(DepType::Code)
             .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).into())
+            .type_(Some(type_script))
             .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.into())
+            .hash_type(hash_type)
             .build()
     }
 
     fn as_type_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(ScriptHashType::Type.into())
+            .hash_type(ScriptHashType::Type)
             .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).into()),
+                    .type_(Some(script)),
             )
         } else {
             (
@@ -228,14 +228,12 @@ 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).into())
-            .build();
+        let cell_output = co_builder.capacity(input_cell.capacity.value() - 1).build();
         let tx = tx_builder
             .cell_dep(self.node.always_success_cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
@@ -266,7 +264,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
         .cell_dep(cell_dep)
         .input(input)
         .output(output)
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
diff --git a/test/src/specs/hardfork/v2023/vm_version2.rs b/test/src/specs/hardfork/v2023/vm_version2.rs
index f28e4dd4c4..aa727f6e89 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.into())
+            .push(id)
             .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.into())
+            .dep_type(DepType::Code)
             .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).into())
+            .type_(Some(type_script))
             .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.into())
+            .hash_type(hash_type)
             .build()
     }
 
     fn as_type_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.type_hash.clone())
-            .hash_type(ScriptHashType::Type.into())
+            .hash_type(ScriptHashType::Type)
             .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).into()),
+                    .type_(Some(script)),
             )
         } else {
             (
@@ -249,14 +249,12 @@ 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).into())
-            .build();
+        let cell_output = co_builder.capacity(input_cell.capacity.value() - 1).build();
         let tx = tx_builder
             .cell_dep(self.node.always_success_cell_dep())
             .input(cell_input)
             .output(cell_output)
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
@@ -287,7 +285,7 @@ impl<'a> CheckVmVersionTestRunner<'a> {
         .cell_dep(cell_dep)
         .input(input)
         .output(output)
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
         if let Some(errmsg) = expected.error_message() {
             assert_send_transaction_fail(self.node, &tx, errmsg);
diff --git a/test/src/specs/mining/basic.rs b/test/src/specs/mining/basic.rs
index f78ec326c6..930fe933fa 100644
--- a/test/src/specs/mining/basic.rs
+++ b/test/src/specs/mining/basic.rs
@@ -49,7 +49,7 @@ impl Spec for BlockTemplates {
                 block1
                     .header()
                     .as_advanced_builder()
-                    .timestamp((block1.header().timestamp() + 1).into())
+                    .timestamp(block1.header().timestamp() + 1)
                     .build(),
             )
             .build();
diff --git a/test/src/specs/mining/bootstrap.rs b/test/src/specs/mining/bootstrap.rs
index 861f718abd..d5ae37b989 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]).into())
-            .code_hash(h256!("0xa2").into())
-            .hash_type(ScriptHashType::Data.into())
+            .args(Bytes::from(vec![2, 1]))
+            .code_hash(h256!("0xa2"))
+            .hash_type(ScriptHashType::Data)
             .build();
 
         let is_bootstrap_cellbase = |number| {
diff --git a/test/src/specs/mining/fee.rs b/test/src/specs/mining/fee.rs
index c9cb84afb4..c7bd9be438 100644
--- a/test/src/specs/mining/fee.rs
+++ b/test/src/specs/mining/fee.rs
@@ -5,14 +5,10 @@ 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},
-    packed::CellOutputBuilder,
+    core::{capacity_bytes, Capacity, TransactionBuilder},
+    packed::{self, CellInput, CellOutput, CellOutputBuilder, OutPoint},
+    prelude::*,
 };
 use rand::{thread_rng, Rng};
 
@@ -79,14 +75,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.into())
+                    .capacity(random_capacity)
                     .lock(cell.cell_output.lock())
                     .type_(cell.cell_output.type_())
                     .build();
                 TransactionBuilder::default()
                     .input(as_input(&cell))
                     .output(output)
-                    .output_data(Default::default())
+                    .output_data(packed::Bytes::default())
                     .cell_dep(node.always_success_cell_dep())
                     .build()
             })
@@ -135,14 +131,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.into())
+                    .capacity(random_capacity)
                     .lock(cell.cell_output.lock())
                     .type_(cell.cell_output.type_())
                     .build();
                 TransactionBuilder::default()
                     .input(as_input(&cell))
                     .output(output)
-                    .output_data(Default::default())
+                    .output_data(packed::Bytes::default())
                     .cell_dep(node.always_success_cell_dep())
                     .build()
             })
@@ -225,7 +221,7 @@ impl Spec for ProposeDuplicated {
             let uncle = node
                 .new_block_builder(None, None, None)
                 .proposal(tx.proposal_short_id())
-                .nonce(99999.into())
+                .nonce(99999)
                 .build()
                 .as_uncle();
             node.mine(1);
@@ -256,7 +252,7 @@ impl Spec for MalformedTx {
         let tx0 = node0.new_transaction_spend_tip_cellbase();
 
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(1000).into())
+            .capacity(capacity_bytes!(1000))
             .build();
 
         let child = tx0
diff --git a/test/src/specs/mining/proposal.rs b/test/src/specs/mining/proposal.rs
index 5a29009c77..eb4abe8a2c 100644
--- a/test/src/specs/mining/proposal.rs
+++ b/test/src/specs/mining/proposal.rs
@@ -20,7 +20,7 @@ impl Spec for AvoidDuplicatedProposalsWithUncles {
             let block = node.new_block(None, None, None);
             let uncle = block
                 .as_advanced_builder()
-                .timestamp((block.timestamp() + 1).into())
+                .timestamp(block.timestamp() + 1)
                 .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 9ef25609bc..6d51311d08 100644
--- a/test/src/specs/mining/uncle.rs
+++ b/test/src/specs/mining/uncle.rs
@@ -85,19 +85,16 @@ impl Spec for UncleInheritFromForkUncle {
 
         let uncle_child = uncle_parent
             .as_advanced_builder()
-            .number((uncle_parent.number() + 1).into())
+            .number(uncle_parent.number() + 1)
             .parent_hash(uncle_parent.hash())
-            .timestamp((uncle_parent.timestamp() + 1).into())
-            .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)
-                }
-                .into(),
-            )
+            .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)
+            })
             .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 1f5b5a2efb..a3d054b98e 100644
--- a/test/src/specs/relay/block_relay.rs
+++ b/test/src/specs/relay/block_relay.rs
@@ -21,7 +21,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).into())
+            .timestamp(now_ms() + future)
             .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 ab2b70a2c7..0cd024796c 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").into())
+                    .parent_hash(h256!("0x123456"))
                     .build(),
             )
             .build();
@@ -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()].into())
+            .transactions(vec![new_tx_2.data()])
             .build();
         let message = packed::RelayMessage::new_builder().set(content).build();
 
@@ -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()].into())
+            .transactions(vec![new_tx_1.data(), new_tx_2.data()])
             .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 b076b37666..9f7083180f 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.into())
+            .proposals(proposal_ids)
             .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 d36fd6b579..b40b22b2da 100644
--- a/test/src/specs/relay/get_block_transactions_process.rs
+++ b/test/src/specs/relay/get_block_transactions_process.rs
@@ -24,21 +24,18 @@ impl Spec for MissingUncleRequest {
         node.mine(1);
 
         let builder = node.new_block_builder(None, None, None);
-        let block1 = builder.clone().nonce(0.into()).build();
-        let block2 = builder.nonce(1.into()).build();
+        let block1 = builder.clone().nonce(0).build();
+        let block2 = builder.nonce(1).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.into())
-            .build();
+        let block = builder.set_uncles(vec![block2.as_uncle()]).nonce(0).build();
         node.submit_block(&block);
 
         let content = packed::GetBlockTransactions::new_builder()
             .block_hash(block.hash())
-            .uncle_indexes([0u32].into())
+            .uncle_indexes([0u32])
             .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 46c7597216..28cd66a3fe 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).into())
+            .capacity(capacity_bytes!(80))
             .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 1aad334416..f172f4b569 100644
--- a/test/src/specs/relay/transaction_relay_low_fee_rate.rs
+++ b/test/src/specs/relay/transaction_relay_low_fee_rate.rs
@@ -5,7 +5,10 @@ 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};
+use ckb_types::{
+    core::{FeeRate, TransactionBuilder},
+    packed,
+};
 
 pub struct TransactionRelayLowFeeRate;
 
@@ -23,7 +26,7 @@ impl Spec for TransactionRelayLowFeeRate {
         let low_fee = TransactionBuilder::default()
             .input(as_input(&cells[0]))
             .output(as_output(&cells[0]))
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .cell_dep(node0.always_success_cell_dep())
             .build();
 
diff --git a/test/src/specs/rpc/submit_block.rs b/test/src/specs/rpc/submit_block.rs
index adfa9ae399..7e1bb10470 100644
--- a/test/src/specs/rpc/submit_block.rs
+++ b/test/src/specs/rpc/submit_block.rs
@@ -14,10 +14,7 @@ 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.into())
-            .build();
+        let block = node0.new_block_builder(None, None, None).number(2).build();
         let block_err = node0
             .rpc_client()
             .submit_block("".to_owned(), block.data().into())
@@ -38,7 +35,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.into())
+            .epoch(epoch)
             .build();
         let block_err = node0
             .rpc_client()
@@ -84,7 +81,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).into())
+            .timestamp(now_ms() + 30_000)
             .build();
         let block_err = node0
             .rpc_client()
@@ -99,7 +96,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).into())
+            .timestamp(median_time - 1)
             .build();
         let block_err = node0
             .rpc_client()
diff --git a/test/src/specs/sync/block_filter.rs b/test/src/specs/sync/block_filter.rs
index cc4f85d83b..0c86a1cb57 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.into())
+                .start_number(start_number)
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -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.into())
+                .start_number(start_number)
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -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.into())
+                .start_number(start_number)
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
@@ -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.into())
+                .start_number(start_number)
                 .build();
             packed::BlockFilterMessage::new_builder()
                 .set(content)
diff --git a/test/src/specs/sync/block_sync.rs b/test/src/specs/sync/block_sync.rs
index 77232ab300..d283150a57 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.into()).build();
-        let new_block2 = new_builder.nonce(1.into()).build();
+        let new_block1 = new_builder.clone().nonce(0).build();
+        let new_block2 = new_builder.nonce(1).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).into())
+            .timestamp(a.timestamp() + 1)
             .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).into())
+                .timestamp(now_ms() + future)
                 .build();
 
             // node1 sync node1 with too new block
@@ -471,9 +471,7 @@ 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().into())
-            .build();
+        let send_headers = SendHeaders::new_builder().headers(Vec::new()).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 d7c777b904..446de599be 100644
--- a/test/src/specs/sync/chain_forks.rs
+++ b/test/src/specs/sync/chain_forks.rs
@@ -147,7 +147,7 @@ impl Spec for ChainFork3 {
             let old_capacity: Capacity = old_output.capacity().into();
             let new_output = old_output
                 .as_builder()
-                .capacity(old_capacity.safe_add(capacity_bytes!(1)).unwrap().into())
+                .capacity(old_capacity.safe_add(capacity_bytes!(1)).unwrap())
                 .build();
             transaction
                 .as_advanced_builder()
@@ -214,7 +214,7 @@ impl Spec for ChainFork4 {
                 .unwrap()
                 .to_entity()
                 .as_builder()
-                .capacity(capacity_bytes!(1).into())
+                .capacity(capacity_bytes!(1))
                 .build();
             transaction
                 .as_advanced_builder()
@@ -402,11 +402,7 @@ 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.into())
-            .build();
+        let previous_output = input.previous_output().as_builder().index(999u32).build();
         let input = input.as_builder().previous_output(previous_output).build();
         let invalid_transaction = transaction
             .as_advanced_builder()
@@ -576,7 +572,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).into())
+            .timestamp(block_a.timestamp() + 2)
             .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 44af4a7143..ed7091959c 100644
--- a/test/src/specs/sync/invalid_locator_size.rs
+++ b/test/src/specs/sync/invalid_locator_size.rs
@@ -27,7 +27,7 @@ impl Spec for InvalidLocatorSize {
         let message = SyncMessage::new_builder()
             .set(
                 GetHeaders::new_builder()
-                    .block_locator_hashes(hashes.into())
+                    .block_locator_hashes(hashes)
                     .build(),
             )
             .build()
diff --git a/test/src/specs/tx_pool/collision.rs b/test/src/specs/tx_pool/collision.rs
index 3a870e7328..0f05d7f580 100644
--- a/test/src/specs/tx_pool/collision.rs
+++ b/test/src/specs/tx_pool/collision.rs
@@ -4,8 +4,11 @@ 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
@@ -213,7 +216,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(Default::default())
+        .witness(packed::Bytes::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 0b7816bf84..77ae8fb619 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.into())
+                .dep_type(DepType::Code)
                 .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.into())
+                .dep_type(DepType::Code)
                 .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.into())
+                .dep_type(DepType::Code)
                 .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 52ce496367..cdd1abf8dd 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).into())
+            .capacity(capacity_bytes!(80))
             .build();
 
         let tx2 = tx2_temp
diff --git a/test/src/specs/tx_pool/limit.rs b/test/src/specs/tx_pool/limit.rs
index ba9a84df80..60e2090ba2 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.into())
+            .dep_type(DepType::Code)
             .out_point(OutPoint::new(tx_a.hash(), 0))
             .build();
 
diff --git a/test/src/specs/tx_pool/orphan_tx.rs b/test/src/specs/tx_pool/orphan_tx.rs
index cb6820d7ce..ac7605dc40 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).into())
+        .capacity(capacity_bytes!(200))
         .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).into())
+        .capacity(capacity_bytes!(80))
         .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).into())
+            .capacity(capacity_bytes!(200))
             .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 277e433f8e..6377216689 100644
--- a/test/src/specs/tx_pool/pool_reconcile.rs
+++ b/test/src/specs/tx_pool/pool_reconcile.rs
@@ -161,7 +161,7 @@ impl Spec for PoolResolveConflictAfterReorg {
                     .build()
             }])
             .set_outputs(vec![CellOutputBuilder::default()
-                .capacity(capacity_bytes!(99).into())
+                .capacity(capacity_bytes!(99))
                 .build()])
             .build();
 
diff --git a/test/src/specs/tx_pool/replace.rs b/test/src/specs/tx_pool/replace.rs
index bad81eb25f..dad1b5107f 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).into())
+            .capacity(capacity_bytes!(70))
             .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).into())
+            .capacity(capacity_bytes!(99))
             .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).into())
+            .capacity(capacity_bytes!(95))
             .build();
 
         let tx2 = tx2_temp
@@ -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).into())
+            .capacity(capacity_bytes!(80))
             .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).into())
+            .capacity(capacity_bytes!(90))
             .build();
 
         let tx2 = tx2_temp
@@ -300,7 +300,7 @@ impl Spec for RbfTooManyDescendants {
 
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70).into())
+            .capacity(capacity_bytes!(70))
             .build();
 
         let tx2 = tx0_temp
@@ -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).into())
+            .capacity(capacity_bytes!(70))
             .build();
 
         let tx2 = clone_tx
@@ -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).into())
+            .capacity(capacity_bytes!(70))
             .build();
 
         let tx2 = clone_tx
@@ -492,7 +492,7 @@ impl Spec for RbfChildPayForParent {
         let max_count = 5;
 
         let output5 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(50).into())
+            .capacity(capacity_bytes!(50))
             .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).into())
+            .capacity(capacity_bytes!(70))
             .build();
 
         let new_tx = clone_tx
@@ -552,7 +552,7 @@ impl Spec for RbfChildPayForParent {
 
         // let's try a new transaction with new higher fee
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(45).into())
+            .capacity(capacity_bytes!(45))
             .build();
         let new_tx_ok = clone_tx
             .as_advanced_builder()
@@ -609,7 +609,7 @@ impl Spec for RbfContainInvalidCells {
 
         // Set tx2 fee to a higher value
         let output2 = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(70).into())
+            .capacity(capacity_bytes!(70))
             .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).into())
+            .capacity(capacity_bytes!(70))
             .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).into())
+            .capacity(capacity_bytes!(70))
             .build();
 
         let tx1_hash = txs[2].hash();
@@ -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.into()).build();
+            let output = CellOutputBuilder::default().capacity(fee).build();
 
             let tx2 = tx2_temp
                 .as_advanced_builder()
@@ -974,7 +974,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.into())
+            .dep_type(DepType::Code)
             .out_point(OutPoint::new(prev.hash(), 0))
             .build();
         let tx_c = tx
@@ -988,7 +988,7 @@ impl Spec for RbfCellDepsCheck {
 
         // Create a new transaction for cell dep with high fee
         let output = CellOutputBuilder::default()
-            .capacity(capacity_bytes!(80).into())
+            .capacity(capacity_bytes!(80))
             .build();
         let new_tx = tx_a
             .as_advanced_builder()
@@ -1160,7 +1160,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).into())
+        .capacity(capacity_bytes!(90))
         .build();
 
     let tx1 = tx1.as_advanced_builder().set_outputs(vec![output]).build();
@@ -1186,7 +1186,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).into())
+        .capacity(capacity_bytes!(95))
         .build();
 
     let tx2 = tx2_temp
diff --git a/test/src/specs/tx_pool/send_defected_binary.rs b/test/src/specs/tx_pool/send_defected_binary.rs
index a28b8d8f26..cc5667af28 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.into())
+            .dep_type(DepType::DepGroup)
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(5000).into())
+            .capacity(capacity_bytes!(5000))
             .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[..].into())
+            .output_data(&data[..])
             .build();
 
         let tx_hash = tx.hash();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).into())
+            .lock(Some(Bytes::from(vec![0u8; 65])))
             .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())).into())
+            .lock(Some(Bytes::from(sig.serialize())))
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .inputs(inputs)
             .output(output)
-            .output_data(data[..].into())
-            .witness(witness.as_bytes().into())
+            .output_data(&data[..])
+            .witness(witness.as_bytes())
             .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 70d2028c9a..26e93c3761 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::{CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
+    packed::{self, 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.into())
-        .code_hash(type_lock_script_code_hash().into())
-        .hash_type(ScriptHashType::Type.into())
+        .args(lock_arg)
+        .code_hash(type_lock_script_code_hash())
+        .hash_type(ScriptHashType::Type)
         .build();
     let cell_dep = CellDep::new_builder()
         .out_point(secp_out_point)
-        .dep_type(DepType::DepGroup.into())
+        .dep_type(DepType::DepGroup)
         .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).into())
+        .capacity(capacity_bytes!(100))
         .lock(lock)
         .build();
     let tx = TransactionBuilder::default()
         .cell_dep(cell_dep)
         .input(input1)
         .output(output1)
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
     let tx_hash: H256 = tx.hash().into();
     let witness = WitnessArgs::new_builder()
-        .lock(Some(Bytes::from(vec![0u8; 65])).into())
+        .lock(Some(Bytes::from(vec![0u8; 65])))
         .build();
     let witness_len = witness.as_slice().len() as u64;
     let message = {
@@ -365,9 +365,7 @@ 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())).into())
+        .lock(Some(Bytes::from(sig.serialize())))
         .build();
-    tx.as_advanced_builder()
-        .witness(witness.as_bytes().into())
-        .build()
+    tx.as_advanced_builder().witness(witness.as_bytes()).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 03341cade9..40a3ebcc6a 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.into())
+            .capacity(capacity)
             .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().into())
+            .capacity(capacity.safe_sub(1000u32).unwrap())
             .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 31c10a2e9f..5eb2c96694 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::{CellDep, CellInput, CellOutput, OutPoint, WitnessArgs},
+    packed::{self, 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.into())
+            .dep_type(DepType::DepGroup)
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .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(Default::default())
+            .output_data(packed::Bytes::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)).into())
+                .lock(Some(Bytes::from(lock)))
                 .build()
         };
         let witness_len = witness.as_slice().len() as u64;
@@ -88,16 +88,13 @@ 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)).into())
-            .build();
+        let witness = witness.as_builder().lock(Some(Bytes::from(lock))).build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .input(input)
             .output(output)
-            .output_data(Default::default())
-            .witness(witness.as_bytes().into())
+            .output_data(packed::Bytes::default())
+            .witness(witness.as_bytes())
             .build();
         info!("Send 1 multisig tx use dep group");
 
diff --git a/test/src/specs/tx_pool/send_secp_tx.rs b/test/src/specs/tx_pool/send_secp_tx.rs
index 4e7c9b0c9e..f8970c236c 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::{CellDep, CellInput, CellOutput, OutPoint, Script, WitnessArgs},
+    packed::{self, 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.into())
+            .dep_type(DepType::DepGroup)
             .build();
         let output = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .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(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx_hash = tx.hash();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).into())
+            .lock(Some(Bytes::from(vec![0u8; 65])))
             .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())).into())
+            .lock(Some(Bytes::from(sig.serialize())))
             .build();
         let tx = TransactionBuilder::default()
             .cell_dep(cell_dep)
             .input(input)
             .output(output)
-            .output_data(Default::default())
-            .witness(witness.as_bytes().into())
+            .output_data(packed::Bytes::default())
+            .witness(witness.as_bytes())
             .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.into())
+            .dep_type(DepType::DepGroup)
             .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).into())
-            .code_hash(type_lock_script_code_hash().into())
-            .hash_type(ScriptHashType::Type.into())
+            .args(&self.lock_arg)
+            .code_hash(type_lock_script_code_hash())
+            .hash_type(ScriptHashType::Type)
             .build();
         let output1 = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .lock(lock.clone())
             .build();
         let output2 = CellOutput::new_builder()
-            .capacity(capacity_bytes!(100).into())
+            .capacity(capacity_bytes!(100))
             .lock(lock)
             .build();
         let tx = TransactionBuilder::default()
@@ -172,13 +172,13 @@ impl Spec for CheckTypical2In2OutTx {
             .input(input2)
             .output(output1)
             .output(output2)
-            .output_data(Default::default())
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx_hash: H256 = tx.hash().into();
         let witness = WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(vec![0u8; 65])).into())
+            .lock(Some(Bytes::from(vec![0u8; 65])))
             .build();
         let witness_len = witness.as_slice().len() as u64;
         let witness2 = Bytes::new();
@@ -197,12 +197,12 @@ impl Spec for CheckTypical2In2OutTx {
         let sig = self.privkey.sign_recoverable(&message).expect("sign");
         let witness = witness
             .as_builder()
-            .lock(Some(Bytes::from(sig.serialize())).into())
+            .lock(Some(Bytes::from(sig.serialize())))
             .build();
         let tx = tx
             .as_advanced_builder()
-            .witness(witness.as_bytes().into())
-            .witness(witness2.into())
+            .witness(witness.as_bytes())
+            .witness(witness2)
             .build();
 
         info!("Send 1 secp tx use dep group");
diff --git a/test/src/txo.rs b/test/src/txo.rs
index 9d3697d98c..98bcc997ae 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::{CellDep, CellInput, CellOutput, OutPoint, Script, ScriptOpt};
+use ckb_types::packed::{self, CellDep, CellInput, CellOutput, OutPoint, Script, ScriptOpt};
 use ckb_types::prelude::*;
 use rand::{thread_rng, Rng};
 use std::collections::HashMap;
@@ -52,7 +52,7 @@ impl TXO {
     pub fn to_equivalent_output(&self) -> CellOutput {
         CellOutput::new_builder()
             .lock(self.lock())
-            .capacity(self.capacity().into())
+            .capacity(self.capacity())
             .build()
     }
 
@@ -145,7 +145,7 @@ impl TXOSet {
                     .cell_deps(cell_deps.clone())
                     .input(txo.to_input())
                     .output(txo.to_equivalent_output())
-                    .output_data(Default::default())
+                    .output_data(packed::Bytes::default())
                     .build()
             })
             .collect()
@@ -166,13 +166,13 @@ impl TXOSet {
                 let output = txo
                     .to_equivalent_output()
                     .as_builder()
-                    .capacity(actual_capacity.into())
+                    .capacity(actual_capacity)
                     .build();
                 TransactionBuilder::default()
                     .cell_deps(cell_deps.clone())
                     .input(txo.to_input())
                     .output(output)
-                    .output_data(Default::default())
+                    .output_data(packed::Bytes::default())
                     .build()
             })
             .collect()
@@ -185,7 +185,7 @@ impl TXOSet {
         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.into()).build());
+                outputs.push(minimal.as_builder().capacity(input_capacity).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.into())
+                    .index(i)
                     .build();
                 TXO::new(out_point, output)
             });
diff --git a/test/src/util/cell.rs b/test/src/util/cell.rs
index 70608c1123..37aaea9c03 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().into())
+        .capacity(cell.capacity())
         .build()
 }
diff --git a/test/src/util/transaction.rs b/test/src/util/transaction.rs
index bf5f7637eb..230251d56c 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(Default::default())
+        .output_data(packed::Bytes::default())
         .cell_dep(node.always_success_cell_dep())
         .build()
 }
@@ -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.pack())
+        .cycles(cycles)
         .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()].into())
+                .tx_hashes(vec![tx.hash()])
                 .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.into())
+        .cycles(cycles)
         .transaction(tx.data())
         .build();
 
diff --git a/test/src/utils.rs b/test/src/utils.rs
index 263ca9291e..c566e874c9 100644
--- a/test/src/utils.rs
+++ b/test/src/utils.rs
@@ -55,8 +55,7 @@ pub fn build_block_transactions(block: &BlockView) -> Bytes {
                 .into_iter()
                 .map(|view| view.data())
                 .skip(1)
-                .collect::<Vec<packed::Transaction>>()
-                .into(),
+                .collect::<Vec<packed::Transaction>>(),
         )
         .build();
 
@@ -72,13 +71,7 @@ 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<_>>()
-                .into(),
-        )
+        .headers(headers.iter().map(|view| view.data()).collect::<Vec<_>>())
         .build();
 
     SyncMessage::new_builder()
@@ -100,8 +93,7 @@ pub fn build_get_blocks(hashes: &[Byte32]) -> Bytes {
             hashes
                 .iter()
                 .map(ToOwned::to_owned)
-                .collect::<Vec<packed::Byte32>>()
-                .into(),
+                .collect::<Vec<packed::Byte32>>(),
         )
         .build();
 
@@ -116,13 +108,13 @@ pub fn build_relay_txs(transactions: &[(TransactionView, u64)]) -> Bytes {
         .iter()
         .map(|(tx, cycles)| {
             RelayTransaction::new_builder()
-                .cycles(cycles.into())
+                .cycles(cycles)
                 .transaction(tx.data())
                 .build()
         })
         .collect::<Vec<packed::RelayTransaction>>();
     let txs = RelayTransactions::new_builder()
-        .transactions(transactions.into())
+        .transactions(transactions)
         .build();
 
     RelayMessage::new_builder().set(txs).build().as_bytes()
@@ -134,8 +126,7 @@ pub fn build_relay_tx_hashes(hashes: &[Byte32]) -> Bytes {
             hashes
                 .iter()
                 .map(ToOwned::to_owned)
-                .collect::<Vec<Byte32>>()
-                .into(),
+                .collect::<Vec<Byte32>>(),
         )
         .build();
 
diff --git a/tx-pool/src/block_assembler/mod.rs b/tx-pool/src/block_assembler/mod.rs
index 661f084b75..dfa9ce3c02 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().into())
-            .code_hash((&config.code_hash).into())
-            .hash_type(hash_type.into())
+            .args(config.args.as_bytes())
+            .code_hash(&config.code_hash)
+            .hash_type(hash_type)
             .build();
         let tip = snapshot.tip_header();
 
@@ -480,7 +480,7 @@ impl BlockAssembler {
 
         CellbaseWitness::new_builder()
             .lock(cellbase_lock)
-            .message(message.into())
+            .message(message)
             .build()
     }
 
@@ -502,11 +502,11 @@ impl BlockAssembler {
             })?;
             let input = CellInput::new_cellbase_input(candidate_number);
             let output = CellOutput::new_builder()
-                .capacity(block_reward.total.into())
+                .capacity(block_reward.total)
                 .lock(target_lock)
                 .build();
 
-            let witness = cellbase_witness.as_bytes().into();
+            let witness = cellbase_witness.as_bytes();
             let no_finalization_target =
                 candidate_number <= snapshot.consensus().finalization_delay_length();
             let tx_builder = TransactionBuilder::default().input(input).witness(witness);
@@ -564,30 +564,28 @@ impl BlockAssembler {
         let block = if let Some(extension) = extension_opt {
             packed::BlockV1::new_builder()
                 .header(header)
-                .transactions(vec![cellbase].into())
+                .transactions(vec![cellbase])
                 .uncles(
                     uncles
                         .iter()
                         .map(|u| u.data())
-                        .collect::<Vec<packed::UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<packed::UncleBlock>>(),
                 )
-                .proposals(proposals.cloned().collect::<Vec<_>>().into())
+                .proposals(proposals.cloned().collect::<Vec<_>>())
                 .extension(extension)
                 .build()
                 .as_v0()
         } else {
             packed::Block::new_builder()
                 .header(header)
-                .transactions(vec![cellbase].into())
+                .transactions(vec![cellbase])
                 .uncles(
                     uncles
                         .iter()
                         .map(|u| u.data())
-                        .collect::<Vec<packed::UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<packed::UncleBlock>>(),
                 )
-                .proposals(proposals.cloned().collect::<Vec<_>>().into())
+                .proposals(proposals.cloned().collect::<Vec<_>>())
                 .build()
         };
         block.serialized_size_without_uncle_proposals()
diff --git a/tx-pool/src/block_assembler/tests.rs b/tx-pool/src/block_assembler/tests.rs
index 8c66d154ca..4b9f15a5fd 100644
--- a/tx-pool/src/block_assembler/tests.rs
+++ b/tx-pool/src/block_assembler/tests.rs
@@ -27,8 +27,12 @@ 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.into())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 10000).into())
+            .number(number)
+            .epoch(EpochNumberWithFraction::new(
+                number / 1000,
+                number % 1000,
+                10000,
+            ))
             .build()
             .as_uncle();
         blocks.push(block);
@@ -57,7 +61,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).into())
+            .timestamp(i as u64)
             .build()
             .as_uncle();
         blocks.push(block);
diff --git a/tx-pool/src/component/tests/chunk.rs b/tx-pool/src/component/tests/chunk.rs
index 39df2dc1cd..9f4f2f1a31 100644
--- a/tx-pool/src/component/tests/chunk.rs
+++ b/tx-pool/src/component/tests/chunk.rs
@@ -2,7 +2,6 @@ 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;
@@ -95,22 +94,22 @@ async fn test_verify_different_cycles() {
 
     let remote = |cycles| Some((cycles, SessionId::default()));
 
-    let tx0 = build_tx(vec![(&H256([0; 32]).pack(), 0)], 1);
+    let tx0 = build_tx(vec![(&H256([0; 32]).into(), 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]).pack(), 0)], 1);
+    let tx1 = build_tx(vec![(&H256([1; 32]).into(), 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]).pack(), 0)], 1);
+    let tx2 = build_tx(vec![(&H256([2; 32]).into(), 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]).pack(), 0)], 1);
+    let tx3 = build_tx(vec![(&H256([3; 32]).into(), 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/proposed.rs b/tx-pool/src/component/tests/proposed.rs
index 86f24b9704..ecac84398b 100644
--- a/tx-pool/src/component/tests/proposed.rs
+++ b/tx-pool/src/component/tests/proposed.rs
@@ -526,27 +526,27 @@ fn test_dep_group() {
         .input(CellInput::new(OutPoint::new(h256!("0x2").into(), 0), 0))
         .output(
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(1000).unwrap().into())
+                .capacity(Capacity::bytes(1000).unwrap())
                 .build(),
         )
-        .output_data((&tx2_data).into())
+        .output_data(&tx2_data)
         .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.into())
+        .dep_type(DepType::DepGroup)
         .build();
     let tx3 = TransactionBuilder::default()
         .cell_dep(dep)
         .input(CellInput::new(OutPoint::new(h256!("0x3").into(), 0), 0))
         .output(
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(3).unwrap().into())
+                .capacity(Capacity::bytes(3).unwrap())
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build();
     let tx3_out_point = OutPoint::new(tx3.hash(), 0);
 
@@ -716,12 +716,12 @@ fn test_container_bench_add_limits() {
                         .previous_output(
                             OutPoint::new_builder()
                                 .tx_hash(prev_tx.transaction().hash())
-                                .index(0u32.into())
+                                .index(0u32)
                                 .build(),
                         )
                         .build(),
                 )
-                .witness(Bytes::new().into())
+                .witness(Bytes::new())
                 .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()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let tx = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1)
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::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 2a3660be7b..0155fa710c 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.into())
+                            .index(0u32)
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().into())
+            .witness(Bytes::new())
             .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.into())
+                            .index(0u32)
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().into())
+            .witness(Bytes::new())
             .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.into())
+                            .index(0u32)
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().into())
+            .witness(Bytes::new())
             .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.into())
+                            .index(0u32)
                             .build(),
                     )
                     .build(),
             )
-            .witness(Bytes::new().into())
+            .witness(Bytes::new())
             .build(),
         200,
         Capacity::shannons(200),
diff --git a/tx-pool/src/component/tests/util.rs b/tx-pool/src/component/tests/util.rs
index aa04530696..d55d37262e 100644
--- a/tx-pool/src/component/tests/util.rs
+++ b/tx-pool/src/component/tests/util.rs
@@ -19,7 +19,7 @@ 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().into())
+                .capacity(Capacity::bytes(i + 1).unwrap())
                 .build()
         }))
         .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
@@ -44,7 +44,7 @@ pub(crate) fn build_tx_with_dep(
         }))
         .outputs((0..outputs_len).map(|i| {
             CellOutput::new_builder()
-                .capacity(Capacity::bytes(i + 1).unwrap().into())
+                .capacity(Capacity::bytes(i + 1).unwrap())
                 .build()
         }))
         .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
@@ -65,7 +65,7 @@ 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().into())
+                .capacity(Capacity::bytes(i + 1).unwrap())
                 .build()
         }))
         .outputs_data((0..outputs_len).map(|_| Bytes::new().into()))
diff --git a/util/dao/src/tests.rs b/util/dao/src/tests.rs
index 586d8b50ba..7ac4ecb24f 100644
--- a/util/dao/src/tests.rs
+++ b/util/dao/src/tests.rs
@@ -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.into())
-        .epoch(epoch.into())
+        .number(parent_number)
+        .epoch(epoch)
         .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.into())
+        .number(parent_number)
         .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.into())
-        .epoch(epoch.into())
+        .number(parent_number)
+        .epoch(epoch)
         .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.into())
-        .epoch(epoch.into())
+        .number(parent_number)
+        .epoch(epoch)
         .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.into())
-        .epoch(epoch.into())
+        .number(parent_number)
+        .epoch(epoch)
         .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).into())
+        .capacity(capacity_bytes!(10000))
         .build();
     let output_cell_data = Bytes::from("abcde12345");
     let output_cell = CellOutput::new_builder()
-        .capacity(capacity_bytes!(20000).into())
+        .capacity(capacity_bytes!(20000))
         .build();
 
     let tx = TransactionBuilder::default()
         .output(output_cell)
-        .output_data(output_cell_data.into())
+        .output_data(output_cell_data)
         .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).into())
+        .capacity(capacity_bytes!(1000000))
         .build();
     let tx = TransactionBuilder::default()
         .output(output.clone())
-        .output_data((&data).into())
+        .output_data(&data)
         .build();
     let epoch = EpochNumberWithFraction::new(1, 100, 1000);
     let deposit_header = HeaderBuilder::default()
-        .number(100.into())
-        .epoch(epoch.into())
+        .number(100)
+        .epoch(epoch)
         .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.into())
-        .epoch(epoch.into())
+        .number(200)
+        .epoch(epoch)
         .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).into())
+        .capacity(Capacity::shannons(18_446_744_073_709_550_000))
         .build();
     let tx = TransactionBuilder::default().output(output.clone()).build();
     let epoch = EpochNumberWithFraction::new(1, 100, 1000);
     let deposit_header = HeaderBuilder::default()
-        .number(100.into())
-        .epoch(epoch.into())
+        .number(100)
+        .epoch(epoch)
         .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.into())
-        .epoch(epoch.into())
+        .number(200)
+        .epoch(epoch)
         .dao(pack_dao_data(
             10_000_000_001_123_456,
             Default::default(),
diff --git a/util/gen-types/src/extension/calc_hash.rs b/util/gen-types/src/extension/calc_hash.rs
index b552ca7e20..ff0b5a2e1c 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()).pack()
+        blake2b_256(self.as_slice()).into()
     }
 }
 
@@ -65,7 +65,7 @@ impl packed::CellOutput {
         if data.is_empty() {
             packed::Byte32::zero()
         } else {
-            blake2b_256(data).pack()
+            blake2b_256(data).into()
         }
     }
 }
@@ -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()).pack()
+        blake2b_256(self.raw_data()).into()
     }
 }
 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.pack()
+            ret.into()
         }
     }
 }
@@ -215,7 +215,7 @@ impl<'r> packed::UncleBlockVecReader<'r> {
                 blake2b.update(uncle.calc_header_hash().as_slice());
             }
             blake2b.finalize(&mut ret);
-            ret.pack()
+            ret.into()
         }
     }
 }
diff --git a/util/gen-types/src/extension/capacity.rs b/util/gen-types/src/extension/capacity.rs
index 7e958d49da..3970406295 100644
--- a/util/gen-types/src/extension/capacity.rs
+++ b/util/gen-types/src/extension/capacity.rs
@@ -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.into()).build())
+            .map(|x| self.capacity(x).build())
     }
 }
 
diff --git a/util/gen-types/src/extension/shortcut.rs b/util/gen-types/src/extension/shortcut.rs
index 6fcc732951..b10f9e68cd 100644
--- a/util/gen-types/src/extension/shortcut.rs
+++ b/util/gen-types/src/extension/shortcut.rs
@@ -48,14 +48,14 @@ impl packed::OutPoint {
     pub fn new(tx_hash: packed::Byte32, index: u32) -> Self {
         packed::OutPoint::new_builder()
             .tx_hash(tx_hash)
-            .index(index.into())
+            .index(index)
             .build()
     }
 
     /// Creates a new null `OutPoint`.
     pub fn null() -> Self {
         packed::OutPoint::new_builder()
-            .index(u32::max_value().into())
+            .index(u32::max_value())
             .build()
     }
 
@@ -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.into())
+            .since(block_number)
             .previous_output(previous_output)
             .build()
     }
diff --git a/util/gen-types/src/extension/tests/calc_hash.rs b/util/gen-types/src/extension/tests/calc_hash.rs
index b0715dd1ec..e828d9b512 100644
--- a/util/gen-types/src/extension/tests/calc_hash.rs
+++ b/util/gen-types/src/extension/tests/calc_hash.rs
@@ -1,100 +1,108 @@
-use crate::{packed, prelude::*, vec};
+use crate::{
+    packed::{self, ProposalShortIdVec, UncleBlockVec},
+    prelude::*,
+    vec,
+};
 use ckb_fixed_hash::h256;
 use ckb_hash::blake2b_256;
 
 #[test]
 fn proposals_hash() {
-    let proposal1 = [1; 10].pack();
-    let proposal2 = [2; 10].pack();
-    let proposals = vec![proposal1, proposal2].pack();
+    let proposal1 = [1; 10].into();
+    let proposal2 = [2; 10].into();
+    let proposals: ProposalShortIdVec = vec![proposal1, proposal2].into();
     let expect = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562");
-    assert_eq!(proposals.calc_proposals_hash(), expect.pack());
+    assert_eq!(proposals.calc_proposals_hash(), expect.into());
 }
 
 #[test]
 fn empty_proposals_hash() {
     let proposals = packed::ProposalShortIdVec::new_builder().build();
     let expect = h256!("0x0");
-    assert_eq!(proposals.calc_proposals_hash(), expect.pack());
+    assert_eq!(proposals.calc_proposals_hash(), expect.into());
 }
 
 #[test]
 fn uncles_hash() {
     let uncle1_raw_header = packed::RawHeader::new_builder()
-        .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())
+        .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"
+        ))
         .build();
     let uncle1_header = packed::Header::new_builder()
         .raw(uncle1_raw_header)
-        .nonce(0x5ff1_389a_f870_6543_11a2_bee6_1237u128.pack())
+        .nonce(0x5ff1_389a_f870_6543_11a2_bee6_1237u128)
         .build();
-    let uncle1_proposals = vec![[1; 10].pack(), [2; 10].pack()].pack();
+    let uncle1_proposals: ProposalShortIdVec = vec![[1; 10].into(), [2; 10].into()].into();
     let uncle1 = packed::UncleBlock::new_builder()
         .header(uncle1_header)
         .proposals(uncle1_proposals)
         .build();
 
     let uncle2_raw_header = packed::RawHeader::new_builder()
-        .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())
+        .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"
+        ))
         .build();
     let uncle2_header = packed::Header::new_builder()
         .raw(uncle2_raw_header)
-        .nonce(0x2f39_2d41_cd70_024fu128.pack())
+        .nonce(0x2f39_2d41_cd70_024fu128)
         .build();
     let uncle2 = packed::UncleBlock::new_builder()
         .header(uncle2_header)
         .build();
 
-    let uncles = vec![uncle1, uncle2].pack();
+    let uncles: UncleBlockVec = vec![uncle1, uncle2].into();
     let expect = h256!("0x0135d01f169a870bd9c92b2b37aecfa0fbfb7c1862cc176e03bb525fab0649d9");
-    assert_eq!(uncles.calc_uncles_hash(), expect.pack());
+    assert_eq!(uncles.calc_uncles_hash(), expect.into());
 }
 
 #[test]
 fn empty_uncles_hash() {
     let uncles = packed::UncleBlockVec::new_builder().build();
     let expect = h256!("0x0");
-    assert_eq!(uncles.calc_uncles_hash(), expect.pack());
+    assert_eq!(uncles.calc_uncles_hash(), expect.into());
 }
 
 #[test]
 fn empty_script_hash() {
     let script = packed::Script::new_builder().build();
     let expect = h256!("0x77c93b0632b5b6c3ef922c5b7cea208fb0a7c427a13d50e13d3fefad17e0c590");
-    assert_eq!(script.calc_script_hash(), expect.pack());
+    assert_eq!(script.calc_script_hash(), expect.into());
 }
 
 #[test]
@@ -103,15 +111,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.pack())
+        .code_hash(always_success_hash)
         .build();
     let expect = h256!("0x4ceaa32f692948413e213ce6f3a83337145bde6e11fd8cb94377ce2637dcc412");
-    assert_eq!(script.calc_script_hash(), expect.pack());
+    assert_eq!(script.calc_script_hash(), expect.into());
 }
 
 #[test]
 fn one_arg_script_hash() {
-    let script = packed::Script::new_builder().args([1].pack()).build();
+    let script = packed::Script::new_builder().args([1]).build();
     let expect = h256!("0x67951b34bce20cb71b7e235c1f8cda259628d99d94825bffe549c23b4dd2930f");
-    assert_eq!(script.calc_script_hash(), expect.pack());
+    assert_eq!(script.calc_script_hash(), expect.into());
 }
diff --git a/util/gen-types/src/extension/tests/capacity.rs b/util/gen-types/src/extension/tests/capacity.rs
index 3502bf6a0b..223bbbb06b 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.pack()).build();
+        let script = packed::Script::new_builder().args(args).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].pack()).build();
+    let lock = packed::Script::new_builder().args([0u8; 20]).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 c66c247392..f4c567c370 100644
--- a/util/gen-types/src/extension/tests/check_data.rs
+++ b/util/gen-types/src/extension/tests/check_data.rs
@@ -1,17 +1,25 @@
-use crate::{borrow::ToOwned, packed, prelude::*};
+use crate::{
+    borrow::ToOwned,
+    packed::{self, Bytes, CellOutput},
+    prelude::*,
+};
 
 fn create_transaction(
     outputs: &[&packed::CellOutput],
     outputs_data: &[&[u8]],
     cell_deps: &[&packed::CellDep],
 ) -> packed::Transaction {
-    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 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 raw = packed::RawTransaction::new_builder()
-        .outputs(outputs_iter.pack())
-        .outputs_data(outputs_data_iter.pack())
-        .cell_deps(cell_deps_iter.pack())
+        .outputs(outputs_iter)
+        .outputs_data(outputs_data_iter)
+        .cell_deps(cell_deps_iter)
         .build();
     packed::Transaction::new_builder().raw(raw).build()
 }
@@ -31,10 +39,10 @@ fn check_data() {
     for ht in 0..4 {
         if ht != 3 {
             for dt in 0..2 {
-                let ht_right = ht.into();
-                let dt_right = dt.into();
-                let ht_error = 3.into();
-                let dt_error = 2.into();
+                let ht_right = ht;
+                let dt_right = dt;
+                let ht_error = 3;
+                let dt_error = 2;
 
                 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 b3e3ce1adb..ee2bd21d9e 100644
--- a/util/gen-types/src/extension/tests/rust_core_traits.rs
+++ b/util/gen-types/src/extension/tests/rust_core_traits.rs
@@ -4,49 +4,50 @@ use numext_fixed_uint::U256;
 
 #[test]
 fn test_uint32_cmp() {
-    let a: Uint32 = 10u32.pack();
-    let b = 20u32.pack();
-    let c = 10u32.pack();
+    let a: Uint32 = 10u32.into();
+    let b = 20u32.into();
+    let c = 10u32.into();
     assert!(a < b);
     assert!(a == c);
 }
 
 #[test]
 fn test_uint64_cmp() {
-    let a: Uint64 = 10u64.pack();
-    let b = 20u64.pack();
-    let c = 10u64.pack();
+    let a: Uint64 = 10u64.into();
+    let b = 20u64.into();
+    let c = 10u64.into();
     assert!(a < b);
     assert!(a == c);
 
-    let a: Uint64 = 1000u64.pack();
-    let b: Uint64 = 2000u64.pack();
+    let a: Uint64 = 1000u64.into();
+    let b: Uint64 = 2000u64.into();
     assert!(a < b);
 }
 
 #[test]
 fn test_uint128_cmp() {
-    let a: Uint128 = 10u128.pack();
-    let b = 20u128.pack();
-    let c = 10u128.pack();
+    let a: Uint128 = 10u128.into();
+    let b = 20u128.into();
+    let c = 10u128.into();
     assert!(a < b);
     assert!(a == c);
 }
 
 #[test]
 fn test_uint256_cmp() {
-    let a = U256::from(10u32).pack();
-    let b = U256::from(20u32).pack();
-    let c = U256::from(10u32).pack();
+    let a: Uint256 = U256::from(10u32).into();
+    let b = U256::from(20u32).into();
+    let c = U256::from(10u32).into();
     assert!(a < b);
     assert!(a == c);
 }
 
 #[test]
 fn test_byte32_cmp() {
-    let a = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack();
-    let b = h256!("0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack();
-    let c = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").pack();
+    let a: Byte32 =
+        h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").into();
+    let b = h256!("0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").into();
+    let c = h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562").into();
 
     assert!(a < b);
     assert!(a == c);
@@ -54,24 +55,27 @@ fn test_byte32_cmp() {
 
 #[test]
 fn test_bytesopt_cmp() {
-    let a = Some(
-        h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562")
-            .pack()
-            .as_bytes(),
+    let a: BytesOpt = Some(
+        Into::<Byte32>::into(h256!(
+            "0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
+        ))
+        .as_bytes(),
     )
-    .pack();
+    .into();
     let b = Some(
-        h256!("0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562")
-            .pack()
-            .as_bytes(),
+        Into::<Byte32>::into(h256!(
+            "0xd2670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
+        ))
+        .as_bytes(),
     )
-    .pack();
+    .into();
     let c = Some(
-        h256!("0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562")
-            .pack()
-            .as_bytes(),
+        Into::<Byte32>::into(h256!(
+            "0xd1670e45af1deb9cc00951d71c09ce80932e7ddf9fb151d744436bd04ac4a562"
+        ))
+        .as_bytes(),
     )
-    .pack();
+    .into();
     let d = BytesOpt::new_builder().build();
 
     assert!(d.is_none());
@@ -82,37 +86,37 @@ fn test_bytesopt_cmp() {
 
 #[test]
 fn test_script_cmp() {
-    let a = Script::new_builder().args([1].pack()).build();
-    let b = Script::new_builder().args([2].pack()).build();
+    let a = Script::new_builder().args([1]).build();
+    let b = Script::new_builder().args([2]).build();
 
     assert!(a < b);
 }
 
 #[test]
 fn test_celldep_cmp() {
-    let a = CellDep::new_builder().dep_type(1.into()).build();
-    let b = CellDep::new_builder().dep_type(2.into()).build();
+    let a = CellDep::new_builder().dep_type(1).build();
+    let b = CellDep::new_builder().dep_type(2).build();
     assert!(a < b);
 }
 
 #[test]
 fn test_outpoint_cmp() {
-    let a = OutPoint::new_builder().index(1u32.pack()).build();
-    let b = OutPoint::new_builder().index(2u32.pack()).build();
+    let a = OutPoint::new_builder().index(1u32).build();
+    let b = OutPoint::new_builder().index(2u32).build();
     assert!(a < b);
 }
 
 #[test]
 fn test_cellinput_cmp() {
-    let a = CellInput::new_builder().since(1000u64.pack()).build();
-    let b = CellInput::new_builder().since(2000u64.pack()).build();
+    let a = CellInput::new_builder().since(1000u64).build();
+    let b = CellInput::new_builder().since(2000u64).build();
     assert!(a > b);
 }
 
 #[test]
 fn test_celloutput_cmp() {
-    let script_lock = Script::new_builder().hash_type(1.into()).build();
-    let script_type = Script::new_builder().hash_type(2.into()).build();
+    let script_lock = Script::new_builder().hash_type(1).build();
+    let script_type = Script::new_builder().hash_type(2).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 40bba83b2f..cc1d1bba48 100644
--- a/util/gen-types/src/extension/tests/serialized_size.rs
+++ b/util/gen-types/src/extension/tests/serialized_size.rs
@@ -1,13 +1,17 @@
-use crate::{packed, prelude::*, vec, vec::Vec};
+use crate::{
+    packed::{self, ProposalShortId, ProposalShortIdVec},
+    prelude::*,
+    vec::Vec,
+};
 
 #[test]
 fn block_size_should_not_include_uncles_proposals() {
-    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 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 uncle0 = packed::UncleBlock::new_builder().build();
     let uncle1 = packed::UncleBlock::new_builder()
         .proposals(proposals1)
@@ -31,11 +35,9 @@ 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().pack())
-                .build();
-            let block_with_uncles = packed::Block::new_builder()
-                .uncles(uncles.clone().pack())
+                .uncles(empty_uncles.clone())
                 .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();
@@ -54,21 +56,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].pack(),
-            [0u8; 24].pack(),
-            [0u8; 48].pack(),
-            [0u8; 72].pack(),
-            [0u8; 96].pack(),
+            [0u8].into(),
+            [0u8; 24].into(),
+            [0u8; 48].into(),
+            [0u8; 72].into(),
+            [0u8; 96].into(),
         ];
         for extension in extensions {
             loop {
                 let block_with_empty_uncles_v1 = packed::BlockV1::new_builder()
-                    .uncles(empty_uncles.clone().pack())
+                    .uncles(empty_uncles.clone())
                     .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().pack())
+                    .uncles(uncles.clone())
                     .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 e9dae42fab..97c34a09c6 100644
--- a/util/gen-types/src/generated/blockchain.rs
+++ b/util/gen-types/src/generated/blockchain.rs
@@ -164,24 +164,39 @@ impl Uint32Builder {
     pub const TOTAL_SIZE: usize = 4;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 4;
-    pub fn set(mut self, v: [Byte; 4]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 4]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
 }
@@ -453,40 +468,67 @@ impl Uint64Builder {
     pub const TOTAL_SIZE: usize = 8;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 8;
-    pub fn set(mut self, v: [Byte; 8]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 8]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
-    pub fn nth4(mut self, v: Byte) -> Self {
-        self.0[4] = v;
+    pub fn nth4<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[4] = v.into();
         self
     }
-    pub fn nth5(mut self, v: Byte) -> Self {
-        self.0[5] = v;
+    pub fn nth5<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[5] = v.into();
         self
     }
-    pub fn nth6(mut self, v: Byte) -> Self {
-        self.0[6] = v;
+    pub fn nth6<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[6] = v.into();
         self
     }
-    pub fn nth7(mut self, v: Byte) -> Self {
-        self.0[7] = v;
+    pub fn nth7<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[7] = v.into();
         self
     }
 }
@@ -835,72 +877,123 @@ impl Uint128Builder {
     pub const TOTAL_SIZE: usize = 16;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 16;
-    pub fn set(mut self, v: [Byte; 16]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 16]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
-    pub fn nth4(mut self, v: Byte) -> Self {
-        self.0[4] = v;
+    pub fn nth4<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[4] = v.into();
         self
     }
-    pub fn nth5(mut self, v: Byte) -> Self {
-        self.0[5] = v;
+    pub fn nth5<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[5] = v.into();
         self
     }
-    pub fn nth6(mut self, v: Byte) -> Self {
-        self.0[6] = v;
+    pub fn nth6<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[6] = v.into();
         self
     }
-    pub fn nth7(mut self, v: Byte) -> Self {
-        self.0[7] = v;
+    pub fn nth7<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[7] = v.into();
         self
     }
-    pub fn nth8(mut self, v: Byte) -> Self {
-        self.0[8] = v;
+    pub fn nth8<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[8] = v.into();
         self
     }
-    pub fn nth9(mut self, v: Byte) -> Self {
-        self.0[9] = v;
+    pub fn nth9<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[9] = v.into();
         self
     }
-    pub fn nth10(mut self, v: Byte) -> Self {
-        self.0[10] = v;
+    pub fn nth10<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[10] = v.into();
         self
     }
-    pub fn nth11(mut self, v: Byte) -> Self {
-        self.0[11] = v;
+    pub fn nth11<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[11] = v.into();
         self
     }
-    pub fn nth12(mut self, v: Byte) -> Self {
-        self.0[12] = v;
+    pub fn nth12<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[12] = v.into();
         self
     }
-    pub fn nth13(mut self, v: Byte) -> Self {
-        self.0[13] = v;
+    pub fn nth13<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[13] = v.into();
         self
     }
-    pub fn nth14(mut self, v: Byte) -> Self {
-        self.0[14] = v;
+    pub fn nth14<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[14] = v.into();
         self
     }
-    pub fn nth15(mut self, v: Byte) -> Self {
-        self.0[15] = v;
+    pub fn nth15<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[15] = v.into();
         self
     }
 }
@@ -1396,136 +1489,235 @@ impl Byte32Builder {
     pub const TOTAL_SIZE: usize = 32;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 32;
-    pub fn set(mut self, v: [Byte; 32]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 32]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
-    pub fn nth4(mut self, v: Byte) -> Self {
-        self.0[4] = v;
+    pub fn nth4<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[4] = v.into();
         self
     }
-    pub fn nth5(mut self, v: Byte) -> Self {
-        self.0[5] = v;
+    pub fn nth5<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[5] = v.into();
         self
     }
-    pub fn nth6(mut self, v: Byte) -> Self {
-        self.0[6] = v;
+    pub fn nth6<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[6] = v.into();
         self
     }
-    pub fn nth7(mut self, v: Byte) -> Self {
-        self.0[7] = v;
+    pub fn nth7<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[7] = v.into();
         self
     }
-    pub fn nth8(mut self, v: Byte) -> Self {
-        self.0[8] = v;
+    pub fn nth8<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[8] = v.into();
         self
     }
-    pub fn nth9(mut self, v: Byte) -> Self {
-        self.0[9] = v;
+    pub fn nth9<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[9] = v.into();
         self
     }
-    pub fn nth10(mut self, v: Byte) -> Self {
-        self.0[10] = v;
+    pub fn nth10<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[10] = v.into();
         self
     }
-    pub fn nth11(mut self, v: Byte) -> Self {
-        self.0[11] = v;
+    pub fn nth11<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[11] = v.into();
         self
     }
-    pub fn nth12(mut self, v: Byte) -> Self {
-        self.0[12] = v;
+    pub fn nth12<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[12] = v.into();
         self
     }
-    pub fn nth13(mut self, v: Byte) -> Self {
-        self.0[13] = v;
+    pub fn nth13<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[13] = v.into();
         self
     }
-    pub fn nth14(mut self, v: Byte) -> Self {
-        self.0[14] = v;
+    pub fn nth14<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[14] = v.into();
         self
     }
-    pub fn nth15(mut self, v: Byte) -> Self {
-        self.0[15] = v;
+    pub fn nth15<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[15] = v.into();
         self
     }
-    pub fn nth16(mut self, v: Byte) -> Self {
-        self.0[16] = v;
+    pub fn nth16<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[16] = v.into();
         self
     }
-    pub fn nth17(mut self, v: Byte) -> Self {
-        self.0[17] = v;
+    pub fn nth17<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[17] = v.into();
         self
     }
-    pub fn nth18(mut self, v: Byte) -> Self {
-        self.0[18] = v;
+    pub fn nth18<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[18] = v.into();
         self
     }
-    pub fn nth19(mut self, v: Byte) -> Self {
-        self.0[19] = v;
+    pub fn nth19<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[19] = v.into();
         self
     }
-    pub fn nth20(mut self, v: Byte) -> Self {
-        self.0[20] = v;
+    pub fn nth20<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[20] = v.into();
         self
     }
-    pub fn nth21(mut self, v: Byte) -> Self {
-        self.0[21] = v;
+    pub fn nth21<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[21] = v.into();
         self
     }
-    pub fn nth22(mut self, v: Byte) -> Self {
-        self.0[22] = v;
+    pub fn nth22<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[22] = v.into();
         self
     }
-    pub fn nth23(mut self, v: Byte) -> Self {
-        self.0[23] = v;
+    pub fn nth23<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[23] = v.into();
         self
     }
-    pub fn nth24(mut self, v: Byte) -> Self {
-        self.0[24] = v;
+    pub fn nth24<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[24] = v.into();
         self
     }
-    pub fn nth25(mut self, v: Byte) -> Self {
-        self.0[25] = v;
+    pub fn nth25<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[25] = v.into();
         self
     }
-    pub fn nth26(mut self, v: Byte) -> Self {
-        self.0[26] = v;
+    pub fn nth26<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[26] = v.into();
         self
     }
-    pub fn nth27(mut self, v: Byte) -> Self {
-        self.0[27] = v;
+    pub fn nth27<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[27] = v.into();
         self
     }
-    pub fn nth28(mut self, v: Byte) -> Self {
-        self.0[28] = v;
+    pub fn nth28<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[28] = v.into();
         self
     }
-    pub fn nth29(mut self, v: Byte) -> Self {
-        self.0[29] = v;
+    pub fn nth29<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[29] = v.into();
         self
     }
-    pub fn nth30(mut self, v: Byte) -> Self {
-        self.0[30] = v;
+    pub fn nth30<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[30] = v.into();
         self
     }
-    pub fn nth31(mut self, v: Byte) -> Self {
-        self.0[31] = v;
+    pub fn nth31<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[31] = v.into();
         self
     }
 }
@@ -2053,136 +2245,235 @@ impl Uint256Builder {
     pub const TOTAL_SIZE: usize = 32;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 32;
-    pub fn set(mut self, v: [Byte; 32]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 32]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
-    pub fn nth4(mut self, v: Byte) -> Self {
-        self.0[4] = v;
+    pub fn nth4<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[4] = v.into();
         self
     }
-    pub fn nth5(mut self, v: Byte) -> Self {
-        self.0[5] = v;
+    pub fn nth5<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[5] = v.into();
         self
     }
-    pub fn nth6(mut self, v: Byte) -> Self {
-        self.0[6] = v;
+    pub fn nth6<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[6] = v.into();
         self
     }
-    pub fn nth7(mut self, v: Byte) -> Self {
-        self.0[7] = v;
+    pub fn nth7<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[7] = v.into();
         self
     }
-    pub fn nth8(mut self, v: Byte) -> Self {
-        self.0[8] = v;
+    pub fn nth8<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[8] = v.into();
         self
     }
-    pub fn nth9(mut self, v: Byte) -> Self {
-        self.0[9] = v;
+    pub fn nth9<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[9] = v.into();
         self
     }
-    pub fn nth10(mut self, v: Byte) -> Self {
-        self.0[10] = v;
+    pub fn nth10<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[10] = v.into();
         self
     }
-    pub fn nth11(mut self, v: Byte) -> Self {
-        self.0[11] = v;
+    pub fn nth11<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[11] = v.into();
         self
     }
-    pub fn nth12(mut self, v: Byte) -> Self {
-        self.0[12] = v;
+    pub fn nth12<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[12] = v.into();
         self
     }
-    pub fn nth13(mut self, v: Byte) -> Self {
-        self.0[13] = v;
+    pub fn nth13<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[13] = v.into();
         self
     }
-    pub fn nth14(mut self, v: Byte) -> Self {
-        self.0[14] = v;
+    pub fn nth14<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[14] = v.into();
         self
     }
-    pub fn nth15(mut self, v: Byte) -> Self {
-        self.0[15] = v;
+    pub fn nth15<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[15] = v.into();
         self
     }
-    pub fn nth16(mut self, v: Byte) -> Self {
-        self.0[16] = v;
+    pub fn nth16<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[16] = v.into();
         self
     }
-    pub fn nth17(mut self, v: Byte) -> Self {
-        self.0[17] = v;
+    pub fn nth17<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[17] = v.into();
         self
     }
-    pub fn nth18(mut self, v: Byte) -> Self {
-        self.0[18] = v;
+    pub fn nth18<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[18] = v.into();
         self
     }
-    pub fn nth19(mut self, v: Byte) -> Self {
-        self.0[19] = v;
+    pub fn nth19<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[19] = v.into();
         self
     }
-    pub fn nth20(mut self, v: Byte) -> Self {
-        self.0[20] = v;
+    pub fn nth20<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[20] = v.into();
         self
     }
-    pub fn nth21(mut self, v: Byte) -> Self {
-        self.0[21] = v;
+    pub fn nth21<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[21] = v.into();
         self
     }
-    pub fn nth22(mut self, v: Byte) -> Self {
-        self.0[22] = v;
+    pub fn nth22<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[22] = v.into();
         self
     }
-    pub fn nth23(mut self, v: Byte) -> Self {
-        self.0[23] = v;
+    pub fn nth23<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[23] = v.into();
         self
     }
-    pub fn nth24(mut self, v: Byte) -> Self {
-        self.0[24] = v;
+    pub fn nth24<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[24] = v.into();
         self
     }
-    pub fn nth25(mut self, v: Byte) -> Self {
-        self.0[25] = v;
+    pub fn nth25<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[25] = v.into();
         self
     }
-    pub fn nth26(mut self, v: Byte) -> Self {
-        self.0[26] = v;
+    pub fn nth26<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[26] = v.into();
         self
     }
-    pub fn nth27(mut self, v: Byte) -> Self {
-        self.0[27] = v;
+    pub fn nth27<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[27] = v.into();
         self
     }
-    pub fn nth28(mut self, v: Byte) -> Self {
-        self.0[28] = v;
+    pub fn nth28<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[28] = v.into();
         self
     }
-    pub fn nth29(mut self, v: Byte) -> Self {
-        self.0[29] = v;
+    pub fn nth29<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[29] = v.into();
         self
     }
-    pub fn nth30(mut self, v: Byte) -> Self {
-        self.0[30] = v;
+    pub fn nth30<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[30] = v.into();
         self
     }
-    pub fn nth31(mut self, v: Byte) -> Self {
-        self.0[31] = v;
+    pub fn nth31<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[31] = v.into();
         self
     }
 }
@@ -2496,18 +2787,24 @@ impl BytesBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Byte) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Byte>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Byte) -> Option<Byte> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Byte>
+    where
+        T: ::core::convert::Into<Byte>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for BytesBuilder {
@@ -2717,8 +3014,11 @@ impl<'r> molecule::prelude::Reader<'r> for BytesOptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct BytesOptBuilder(pub(crate) Option<Bytes>);
 impl BytesOptBuilder {
-    pub fn set(mut self, v: Option<Bytes>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<Bytes>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -2979,18 +3279,24 @@ impl BytesOptVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: BytesOpt) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = BytesOpt>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: BytesOpt) -> Option<BytesOpt> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<BytesOpt>
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for BytesOptVecBuilder {
@@ -3327,18 +3633,24 @@ impl BytesVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Bytes) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Bytes>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Bytes) -> Option<Bytes> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Bytes>
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for BytesVecBuilder {
@@ -3632,18 +3944,24 @@ impl Byte32VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Byte32) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Byte32>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Byte32) -> Option<Byte32> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Byte32>
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for Byte32VecBuilder {
@@ -3862,8 +4180,11 @@ impl<'r> molecule::prelude::Reader<'r> for ScriptOptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct ScriptOptBuilder(pub(crate) Option<Script>);
 impl ScriptOptBuilder {
-    pub fn set(mut self, v: Option<Script>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<Script>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -4110,48 +4431,81 @@ impl ProposalShortIdBuilder {
     pub const TOTAL_SIZE: usize = 10;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 10;
-    pub fn set(mut self, v: [Byte; 10]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 10]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
-    pub fn nth4(mut self, v: Byte) -> Self {
-        self.0[4] = v;
+    pub fn nth4<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[4] = v.into();
         self
     }
-    pub fn nth5(mut self, v: Byte) -> Self {
-        self.0[5] = v;
+    pub fn nth5<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[5] = v.into();
         self
     }
-    pub fn nth6(mut self, v: Byte) -> Self {
-        self.0[6] = v;
+    pub fn nth6<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[6] = v.into();
         self
     }
-    pub fn nth7(mut self, v: Byte) -> Self {
-        self.0[7] = v;
+    pub fn nth7<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[7] = v.into();
         self
     }
-    pub fn nth8(mut self, v: Byte) -> Self {
-        self.0[8] = v;
+    pub fn nth8<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[8] = v.into();
         self
     }
-    pub fn nth9(mut self, v: Byte) -> Self {
-        self.0[9] = v;
+    pub fn nth9<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[9] = v.into();
         self
     }
 }
@@ -4470,18 +4824,24 @@ impl UncleBlockVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: UncleBlock) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<UncleBlock>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = UncleBlock>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: UncleBlock) -> Option<UncleBlock> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<UncleBlock>
+    where
+        T: ::core::convert::Into<UncleBlock>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for UncleBlockVecBuilder {
@@ -4818,18 +5178,24 @@ impl TransactionVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Transaction) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Transaction>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Transaction>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Transaction) -> Option<Transaction> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Transaction>
+    where
+        T: ::core::convert::Into<Transaction>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for TransactionVecBuilder {
@@ -5123,8 +5489,11 @@ impl ProposalShortIdVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: ProposalShortId) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortId>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = ProposalShortId>>(
@@ -5134,10 +5503,13 @@ impl ProposalShortIdVecBuilder {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: ProposalShortId) -> Option<ProposalShortId> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<ProposalShortId>
+    where
+        T: ::core::convert::Into<ProposalShortId>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for ProposalShortIdVecBuilder {
@@ -5406,18 +5778,24 @@ impl CellDepVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: CellDep) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellDep>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellDep>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: CellDep) -> Option<CellDep> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<CellDep>
+    where
+        T: ::core::convert::Into<CellDep>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for CellDepVecBuilder {
@@ -5686,18 +6064,24 @@ impl CellInputVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: CellInput) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellInput>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellInput>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: CellInput) -> Option<CellInput> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<CellInput>
+    where
+        T: ::core::convert::Into<CellInput>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for CellInputVecBuilder {
@@ -6009,18 +6393,24 @@ impl CellOutputVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: CellOutput) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellOutput>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = CellOutput>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: CellOutput) -> Option<CellOutput> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<CellOutput>
+    where
+        T: ::core::convert::Into<CellOutput>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for CellOutputVecBuilder {
@@ -6368,16 +6758,25 @@ pub struct ScriptBuilder {
 }
 impl ScriptBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn code_hash(mut self, v: Byte32) -> Self {
-        self.code_hash = v;
+    pub fn code_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.code_hash = v.into();
         self
     }
-    pub fn hash_type(mut self, v: Byte) -> Self {
-        self.hash_type = v;
+    pub fn hash_type<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.hash_type = v.into();
         self
     }
-    pub fn args(mut self, v: Bytes) -> Self {
-        self.args = v;
+    pub fn args<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.args = v.into();
         self
     }
 }
@@ -6555,12 +6954,18 @@ 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(mut self, v: Byte32) -> Self {
-        self.tx_hash = v;
+    pub fn tx_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.tx_hash = v.into();
         self
     }
-    pub fn index(mut self, v: Uint32) -> Self {
-        self.index = v;
+    pub fn index<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.index = v.into();
         self
     }
 }
@@ -6722,12 +7127,18 @@ 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(mut self, v: Uint64) -> Self {
-        self.since = v;
+    pub fn since<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.since = v.into();
         self
     }
-    pub fn previous_output(mut self, v: OutPoint) -> Self {
-        self.previous_output = v;
+    pub fn previous_output<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<OutPoint>,
+    {
+        self.previous_output = v.into();
         self
     }
 }
@@ -6991,16 +7402,25 @@ pub struct CellOutputBuilder {
 }
 impl CellOutputBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn capacity(mut self, v: Uint64) -> Self {
-        self.capacity = v;
+    pub fn capacity<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.capacity = v.into();
         self
     }
-    pub fn lock(mut self, v: Script) -> Self {
-        self.lock = v;
+    pub fn lock<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Script>,
+    {
+        self.lock = v.into();
         self
     }
-    pub fn type_(mut self, v: ScriptOpt) -> Self {
-        self.type_ = v;
+    pub fn type_<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ScriptOpt>,
+    {
+        self.type_ = v.into();
         self
     }
 }
@@ -7178,12 +7598,18 @@ 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(mut self, v: OutPoint) -> Self {
-        self.out_point = v;
+    pub fn out_point<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<OutPoint>,
+    {
+        self.out_point = v.into();
         self
     }
-    pub fn dep_type(mut self, v: Byte) -> Self {
-        self.dep_type = v;
+    pub fn dep_type<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.dep_type = v.into();
         self
     }
 }
@@ -7497,28 +7923,46 @@ pub struct RawTransactionBuilder {
 }
 impl RawTransactionBuilder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn version(mut self, v: Uint32) -> Self {
-        self.version = v;
+    pub fn version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.version = v.into();
         self
     }
-    pub fn cell_deps(mut self, v: CellDepVec) -> Self {
-        self.cell_deps = v;
+    pub fn cell_deps<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellDepVec>,
+    {
+        self.cell_deps = v.into();
         self
     }
-    pub fn header_deps(mut self, v: Byte32Vec) -> Self {
-        self.header_deps = v;
+    pub fn header_deps<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.header_deps = v.into();
         self
     }
-    pub fn inputs(mut self, v: CellInputVec) -> Self {
-        self.inputs = v;
+    pub fn inputs<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellInputVec>,
+    {
+        self.inputs = v.into();
         self
     }
-    pub fn outputs(mut self, v: CellOutputVec) -> Self {
-        self.outputs = v;
+    pub fn outputs<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellOutputVec>,
+    {
+        self.outputs = v.into();
         self
     }
-    pub fn outputs_data(mut self, v: BytesVec) -> Self {
-        self.outputs_data = v;
+    pub fn outputs_data<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesVec>,
+    {
+        self.outputs_data = v.into();
         self
     }
 }
@@ -7793,12 +8237,18 @@ pub struct TransactionBuilder {
 }
 impl TransactionBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn raw(mut self, v: RawTransaction) -> Self {
-        self.raw = v;
+    pub fn raw<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<RawTransaction>,
+    {
+        self.raw = v.into();
         self
     }
-    pub fn witnesses(mut self, v: BytesVec) -> Self {
-        self.witnesses = v;
+    pub fn witnesses<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesVec>,
+    {
+        self.witnesses = v.into();
         self
     }
 }
@@ -8057,44 +8507,74 @@ 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(mut self, v: Uint32) -> Self {
-        self.version = v;
+    pub fn version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.version = v.into();
         self
     }
-    pub fn compact_target(mut self, v: Uint32) -> Self {
-        self.compact_target = v;
+    pub fn compact_target<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.compact_target = v.into();
         self
     }
-    pub fn timestamp(mut self, v: Uint64) -> Self {
-        self.timestamp = v;
+    pub fn timestamp<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.timestamp = v.into();
         self
     }
-    pub fn number(mut self, v: Uint64) -> Self {
-        self.number = v;
+    pub fn number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.number = v.into();
         self
     }
-    pub fn epoch(mut self, v: Uint64) -> Self {
-        self.epoch = v;
+    pub fn epoch<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.epoch = v.into();
         self
     }
-    pub fn parent_hash(mut self, v: Byte32) -> Self {
-        self.parent_hash = v;
+    pub fn parent_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.parent_hash = v.into();
         self
     }
-    pub fn transactions_root(mut self, v: Byte32) -> Self {
-        self.transactions_root = v;
+    pub fn transactions_root<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.transactions_root = v.into();
         self
     }
-    pub fn proposals_hash(mut self, v: Byte32) -> Self {
-        self.proposals_hash = v;
+    pub fn proposals_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.proposals_hash = v.into();
         self
     }
-    pub fn extra_hash(mut self, v: Byte32) -> Self {
-        self.extra_hash = v;
+    pub fn extra_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.extra_hash = v.into();
         self
     }
-    pub fn dao(mut self, v: Byte32) -> Self {
-        self.dao = v;
+    pub fn dao<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.dao = v.into();
         self
     }
 }
@@ -8267,12 +8747,18 @@ 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(mut self, v: RawHeader) -> Self {
-        self.raw = v;
+    pub fn raw<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<RawHeader>,
+    {
+        self.raw = v.into();
         self
     }
-    pub fn nonce(mut self, v: Uint128) -> Self {
-        self.nonce = v;
+    pub fn nonce<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint128>,
+    {
+        self.nonce = v.into();
         self
     }
 }
@@ -8524,12 +9010,18 @@ pub struct UncleBlockBuilder {
 }
 impl UncleBlockBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
-        self.proposals = v;
+    pub fn proposals<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.proposals = v.into();
         self
     }
 }
@@ -8828,20 +9320,32 @@ pub struct BlockBuilder {
 }
 impl BlockBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn uncles(mut self, v: UncleBlockVec) -> Self {
-        self.uncles = v;
+    pub fn uncles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<UncleBlockVec>,
+    {
+        self.uncles = v.into();
         self
     }
-    pub fn transactions(mut self, v: TransactionVec) -> Self {
-        self.transactions = v;
+    pub fn transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<TransactionVec>,
+    {
+        self.transactions = v.into();
         self
     }
-    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
-        self.proposals = v;
+    pub fn proposals<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.proposals = v.into();
         self
     }
 }
@@ -9165,24 +9669,39 @@ pub struct BlockV1Builder {
 }
 impl BlockV1Builder {
     pub const FIELD_COUNT: usize = 5;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn uncles(mut self, v: UncleBlockVec) -> Self {
-        self.uncles = v;
+    pub fn uncles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<UncleBlockVec>,
+    {
+        self.uncles = v.into();
         self
     }
-    pub fn transactions(mut self, v: TransactionVec) -> Self {
-        self.transactions = v;
+    pub fn transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<TransactionVec>,
+    {
+        self.transactions = v.into();
         self
     }
-    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
-        self.proposals = v;
+    pub fn proposals<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.proposals = v.into();
         self
     }
-    pub fn extension(mut self, v: Bytes) -> Self {
-        self.extension = v;
+    pub fn extension<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.extension = v.into();
         self
     }
 }
@@ -9453,12 +9972,18 @@ pub struct CellbaseWitnessBuilder {
 }
 impl CellbaseWitnessBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn lock(mut self, v: Script) -> Self {
-        self.lock = v;
+    pub fn lock<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Script>,
+    {
+        self.lock = v.into();
         self
     }
-    pub fn message(mut self, v: Bytes) -> Self {
-        self.message = v;
+    pub fn message<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.message = v.into();
         self
     }
 }
@@ -9730,16 +10255,25 @@ pub struct WitnessArgsBuilder {
 }
 impl WitnessArgsBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn lock(mut self, v: BytesOpt) -> Self {
-        self.lock = v;
+    pub fn lock<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.lock = v.into();
         self
     }
-    pub fn input_type(mut self, v: BytesOpt) -> Self {
-        self.input_type = v;
+    pub fn input_type<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.input_type = v.into();
         self
     }
-    pub fn output_type(mut self, v: BytesOpt) -> Self {
-        self.output_type = v;
+    pub fn output_type<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.output_type = v.into();
         self
     }
 }
diff --git a/util/gen-types/src/generated/extensions.rs b/util/gen-types/src/generated/extensions.rs
index a8c3ca21b1..1a37fc235e 100644
--- a/util/gen-types/src/generated/extensions.rs
+++ b/util/gen-types/src/generated/extensions.rs
@@ -139,8 +139,11 @@ impl<'r> molecule::prelude::Reader<'r> for BoolOptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct BoolOptBuilder(pub(crate) Option<Bool>);
 impl BoolOptBuilder {
-    pub fn set(mut self, v: Option<Bool>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<Bool>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -308,8 +311,11 @@ impl<'r> molecule::prelude::Reader<'r> for Byte32OptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct Byte32OptBuilder(pub(crate) Option<Byte32>);
 impl Byte32OptBuilder {
-    pub fn set(mut self, v: Option<Byte32>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<Byte32>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -480,12 +486,18 @@ impl BoolBuilder {
     pub const TOTAL_SIZE: usize = 1;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 1;
-    pub fn set(mut self, v: [Byte; 1]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 1]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
 }
@@ -717,24 +729,39 @@ impl BeUint32Builder {
     pub const TOTAL_SIZE: usize = 4;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 4;
-    pub fn set(mut self, v: [Byte; 4]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 4]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
 }
@@ -1006,40 +1033,67 @@ impl BeUint64Builder {
     pub const TOTAL_SIZE: usize = 8;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 8;
-    pub fn set(mut self, v: [Byte; 8]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 8]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
-    pub fn nth2(mut self, v: Byte) -> Self {
-        self.0[2] = v;
+    pub fn nth2<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[2] = v.into();
         self
     }
-    pub fn nth3(mut self, v: Byte) -> Self {
-        self.0[3] = v;
+    pub fn nth3<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[3] = v.into();
         self
     }
-    pub fn nth4(mut self, v: Byte) -> Self {
-        self.0[4] = v;
+    pub fn nth4<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[4] = v.into();
         self
     }
-    pub fn nth5(mut self, v: Byte) -> Self {
-        self.0[5] = v;
+    pub fn nth5<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[5] = v.into();
         self
     }
-    pub fn nth6(mut self, v: Byte) -> Self {
-        self.0[6] = v;
+    pub fn nth6<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[6] = v.into();
         self
     }
-    pub fn nth7(mut self, v: Byte) -> Self {
-        self.0[7] = v;
+    pub fn nth7<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[7] = v.into();
         self
     }
 }
@@ -1311,18 +1365,24 @@ impl Uint32VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Uint32) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint32>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Uint32) -> Option<Uint32> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Uint32>
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for Uint32VecBuilder {
@@ -1591,18 +1651,24 @@ impl Uint64VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Uint64) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint64>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Uint64) -> Option<Uint64> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Uint64>
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for Uint64VecBuilder {
@@ -1871,18 +1937,24 @@ impl Uint256VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Uint256) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint256>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Uint256>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Uint256) -> Option<Uint256> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Uint256>
+    where
+        T: ::core::convert::Into<Uint256>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for Uint256VecBuilder {
@@ -2101,8 +2173,11 @@ impl<'r> molecule::prelude::Reader<'r> for CellOutputOptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct CellOutputOptBuilder(pub(crate) Option<CellOutput>);
 impl CellOutputOptBuilder {
-    pub fn set(mut self, v: Option<CellOutput>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<CellOutput>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -2320,18 +2395,24 @@ impl HeaderVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Header) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Header>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Header) -> Option<Header> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Header>
+    where
+        T: ::core::convert::Into<Header>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for HeaderVecBuilder {
@@ -2600,18 +2681,24 @@ impl OutPointVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: OutPoint) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<OutPoint>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = OutPoint>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: OutPoint) -> Option<OutPoint> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<OutPoint>
+    where
+        T: ::core::convert::Into<OutPoint>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for OutPointVecBuilder {
@@ -2830,8 +2917,11 @@ impl<'r> molecule::prelude::Reader<'r> for Uint64VecOptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct Uint64VecOptBuilder(pub(crate) Option<Uint64Vec>);
 impl Uint64VecOptBuilder {
-    pub fn set(mut self, v: Option<Uint64Vec>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<Uint64Vec>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -3104,44 +3194,74 @@ 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(mut self, v: Byte32) -> Self {
-        self.children_hash = v;
+    pub fn children_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.children_hash = v.into();
         self
     }
-    pub fn total_difficulty(mut self, v: Uint256) -> Self {
-        self.total_difficulty = v;
+    pub fn total_difficulty<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint256>,
+    {
+        self.total_difficulty = v.into();
         self
     }
-    pub fn start_number(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
-    pub fn end_number(mut self, v: Uint64) -> Self {
-        self.end_number = v;
+    pub fn end_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.end_number = v.into();
         self
     }
-    pub fn start_epoch(mut self, v: Uint64) -> Self {
-        self.start_epoch = v;
+    pub fn start_epoch<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_epoch = v.into();
         self
     }
-    pub fn end_epoch(mut self, v: Uint64) -> Self {
-        self.end_epoch = v;
+    pub fn end_epoch<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.end_epoch = v.into();
         self
     }
-    pub fn start_timestamp(mut self, v: Uint64) -> Self {
-        self.start_timestamp = v;
+    pub fn start_timestamp<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_timestamp = v.into();
         self
     }
-    pub fn end_timestamp(mut self, v: Uint64) -> Self {
-        self.end_timestamp = v;
+    pub fn end_timestamp<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.end_timestamp = v.into();
         self
     }
-    pub fn start_compact_target(mut self, v: Uint32) -> Self {
-        self.start_compact_target = v;
+    pub fn start_compact_target<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.start_compact_target = v.into();
         self
     }
-    pub fn end_compact_target(mut self, v: Uint32) -> Self {
-        self.end_compact_target = v;
+    pub fn end_compact_target<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.end_compact_target = v.into();
         self
     }
 }
@@ -3315,12 +3435,18 @@ 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(mut self, v: Byte32) -> Self {
-        self.hash = v;
+    pub fn hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.hash = v.into();
         self
     }
-    pub fn data(mut self, v: Header) -> Self {
-        self.data = v;
+    pub fn data<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.data = v.into();
         self
     }
 }
@@ -3563,12 +3689,18 @@ pub struct UncleBlockVecViewBuilder {
 }
 impl UncleBlockVecViewBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn hashes(mut self, v: Byte32Vec) -> Self {
-        self.hashes = v;
+    pub fn hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.hashes = v.into();
         self
     }
-    pub fn data(mut self, v: UncleBlockVec) -> Self {
-        self.data = v;
+    pub fn data<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<UncleBlockVec>,
+    {
+        self.data = v.into();
         self
     }
 }
@@ -3847,16 +3979,25 @@ pub struct TransactionViewBuilder {
 }
 impl TransactionViewBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn hash(mut self, v: Byte32) -> Self {
-        self.hash = v;
+    pub fn hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.hash = v.into();
         self
     }
-    pub fn witness_hash(mut self, v: Byte32) -> Self {
-        self.witness_hash = v;
+    pub fn witness_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.witness_hash = v.into();
         self
     }
-    pub fn data(mut self, v: Transaction) -> Self {
-        self.data = v;
+    pub fn data<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Transaction>,
+    {
+        self.data = v.into();
         self
     }
 }
@@ -4180,24 +4321,39 @@ pub struct BlockExtBuilder {
 }
 impl BlockExtBuilder {
     pub const FIELD_COUNT: usize = 5;
-    pub fn total_difficulty(mut self, v: Uint256) -> Self {
-        self.total_difficulty = v;
+    pub fn total_difficulty<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint256>,
+    {
+        self.total_difficulty = v.into();
         self
     }
-    pub fn total_uncles_count(mut self, v: Uint64) -> Self {
-        self.total_uncles_count = v;
+    pub fn total_uncles_count<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.total_uncles_count = v.into();
         self
     }
-    pub fn received_at(mut self, v: Uint64) -> Self {
-        self.received_at = v;
+    pub fn received_at<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.received_at = v.into();
         self
     }
-    pub fn txs_fees(mut self, v: Uint64Vec) -> Self {
-        self.txs_fees = v;
+    pub fn txs_fees<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64Vec>,
+    {
+        self.txs_fees = v.into();
         self
     }
-    pub fn verified(mut self, v: BoolOpt) -> Self {
-        self.verified = v;
+    pub fn verified<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BoolOpt>,
+    {
+        self.verified = v.into();
         self
     }
 }
@@ -4563,32 +4719,53 @@ pub struct BlockExtV1Builder {
 }
 impl BlockExtV1Builder {
     pub const FIELD_COUNT: usize = 7;
-    pub fn total_difficulty(mut self, v: Uint256) -> Self {
-        self.total_difficulty = v;
+    pub fn total_difficulty<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint256>,
+    {
+        self.total_difficulty = v.into();
         self
     }
-    pub fn total_uncles_count(mut self, v: Uint64) -> Self {
-        self.total_uncles_count = v;
+    pub fn total_uncles_count<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.total_uncles_count = v.into();
         self
     }
-    pub fn received_at(mut self, v: Uint64) -> Self {
-        self.received_at = v;
+    pub fn received_at<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.received_at = v.into();
         self
     }
-    pub fn txs_fees(mut self, v: Uint64Vec) -> Self {
-        self.txs_fees = v;
+    pub fn txs_fees<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64Vec>,
+    {
+        self.txs_fees = v.into();
         self
     }
-    pub fn verified(mut self, v: BoolOpt) -> Self {
-        self.verified = v;
+    pub fn verified<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BoolOpt>,
+    {
+        self.verified = v.into();
         self
     }
-    pub fn cycles(mut self, v: Uint64VecOpt) -> Self {
-        self.cycles = v;
+    pub fn cycles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64VecOpt>,
+    {
+        self.cycles = v.into();
         self
     }
-    pub fn txs_sizes(mut self, v: Uint64VecOpt) -> Self {
-        self.txs_sizes = v;
+    pub fn txs_sizes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64VecOpt>,
+    {
+        self.txs_sizes = v.into();
         self
     }
 }
@@ -4864,36 +5041,60 @@ 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(mut self, v: Uint256) -> Self {
-        self.previous_epoch_hash_rate = v;
+    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();
         self
     }
-    pub fn last_block_hash_in_previous_epoch(mut self, v: Byte32) -> Self {
-        self.last_block_hash_in_previous_epoch = v;
+    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();
         self
     }
-    pub fn compact_target(mut self, v: Uint32) -> Self {
-        self.compact_target = v;
+    pub fn compact_target<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.compact_target = v.into();
         self
     }
-    pub fn number(mut self, v: Uint64) -> Self {
-        self.number = v;
+    pub fn number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.number = v.into();
         self
     }
-    pub fn base_block_reward(mut self, v: Uint64) -> Self {
-        self.base_block_reward = v;
+    pub fn base_block_reward<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.base_block_reward = v.into();
         self
     }
-    pub fn remainder_reward(mut self, v: Uint64) -> Self {
-        self.remainder_reward = v;
+    pub fn remainder_reward<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.remainder_reward = v.into();
         self
     }
-    pub fn start_number(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
-    pub fn length(mut self, v: Uint64) -> Self {
-        self.length = v;
+    pub fn length<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.length = v.into();
         self
     }
 }
@@ -5061,12 +5262,18 @@ 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(mut self, v: Byte32) -> Self {
-        self.block_hash = v;
+    pub fn block_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.block_hash = v.into();
         self
     }
-    pub fn index(mut self, v: BeUint32) -> Self {
-        self.index = v;
+    pub fn index<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BeUint32>,
+    {
+        self.index = v.into();
         self
     }
 }
@@ -5228,12 +5435,18 @@ 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(mut self, v: Uint64) -> Self {
-        self.number = v;
+    pub fn number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.number = v.into();
         self
     }
-    pub fn block_hash(mut self, v: Byte32) -> Self {
-        self.block_hash = v;
+    pub fn block_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.block_hash = v.into();
         self
     }
 }
@@ -5405,16 +5618,25 @@ 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(mut self, v: Uint64) -> Self {
-        self.block_number = v;
+    pub fn block_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.block_number = v.into();
         self
     }
-    pub fn block_epoch(mut self, v: Uint64) -> Self {
-        self.block_epoch = v;
+    pub fn block_epoch<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.block_epoch = v.into();
         self
     }
-    pub fn key(mut self, v: TransactionKey) -> Self {
-        self.key = v;
+    pub fn key<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<TransactionKey>,
+    {
+        self.key = v.into();
         self
     }
 }
@@ -5733,28 +5955,46 @@ pub struct CellEntryBuilder {
 }
 impl CellEntryBuilder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn output(mut self, v: CellOutput) -> Self {
-        self.output = v;
+    pub fn output<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<CellOutput>,
+    {
+        self.output = v.into();
         self
     }
-    pub fn block_hash(mut self, v: Byte32) -> Self {
-        self.block_hash = v;
+    pub fn block_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.block_hash = v.into();
         self
     }
-    pub fn block_number(mut self, v: Uint64) -> Self {
-        self.block_number = v;
+    pub fn block_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.block_number = v.into();
         self
     }
-    pub fn block_epoch(mut self, v: Uint64) -> Self {
-        self.block_epoch = v;
+    pub fn block_epoch<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.block_epoch = v.into();
         self
     }
-    pub fn index(mut self, v: Uint32) -> Self {
-        self.index = v;
+    pub fn index<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.index = v.into();
         self
     }
-    pub fn data_size(mut self, v: Uint64) -> Self {
-        self.data_size = v;
+    pub fn data_size<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.data_size = v.into();
         self
     }
 }
@@ -6028,12 +6268,18 @@ pub struct CellDataEntryBuilder {
 }
 impl CellDataEntryBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn output_data(mut self, v: Bytes) -> Self {
-        self.output_data = v;
+    pub fn output_data<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.output_data = v.into();
         self
     }
-    pub fn output_data_hash(mut self, v: Byte32) -> Self {
-        self.output_data_hash = v;
+    pub fn output_data_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.output_data_hash = v.into();
         self
     }
 }
@@ -6926,24 +7172,39 @@ pub struct CompactBlockBuilder {
 }
 impl CompactBlockBuilder {
     pub const FIELD_COUNT: usize = 5;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn short_ids(mut self, v: ProposalShortIdVec) -> Self {
-        self.short_ids = v;
+    pub fn short_ids<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.short_ids = v.into();
         self
     }
-    pub fn prefilled_transactions(mut self, v: IndexTransactionVec) -> Self {
-        self.prefilled_transactions = v;
+    pub fn prefilled_transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<IndexTransactionVec>,
+    {
+        self.prefilled_transactions = v.into();
         self
     }
-    pub fn uncles(mut self, v: Byte32Vec) -> Self {
-        self.uncles = v;
+    pub fn uncles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.uncles = v.into();
         self
     }
-    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
-        self.proposals = v;
+    pub fn proposals<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.proposals = v.into();
         self
     }
 }
@@ -7298,28 +7559,46 @@ pub struct CompactBlockV1Builder {
 }
 impl CompactBlockV1Builder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn short_ids(mut self, v: ProposalShortIdVec) -> Self {
-        self.short_ids = v;
+    pub fn short_ids<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.short_ids = v.into();
         self
     }
-    pub fn prefilled_transactions(mut self, v: IndexTransactionVec) -> Self {
-        self.prefilled_transactions = v;
+    pub fn prefilled_transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<IndexTransactionVec>,
+    {
+        self.prefilled_transactions = v.into();
         self
     }
-    pub fn uncles(mut self, v: Byte32Vec) -> Self {
-        self.uncles = v;
+    pub fn uncles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.uncles = v.into();
         self
     }
-    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
-        self.proposals = v;
+    pub fn proposals<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.proposals = v.into();
         self
     }
-    pub fn extension(mut self, v: Bytes) -> Self {
-        self.extension = v;
+    pub fn extension<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.extension = v.into();
         self
     }
 }
@@ -7595,12 +7874,18 @@ pub struct RelayTransactionBuilder {
 }
 impl RelayTransactionBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn cycles(mut self, v: Uint64) -> Self {
-        self.cycles = v;
+    pub fn cycles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.cycles = v.into();
         self
     }
-    pub fn transaction(mut self, v: Transaction) -> Self {
-        self.transaction = v;
+    pub fn transaction<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Transaction>,
+    {
+        self.transaction = v.into();
         self
     }
 }
@@ -7864,8 +8149,11 @@ impl RelayTransactionVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: RelayTransaction) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<RelayTransaction>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = RelayTransaction>>(
@@ -7875,10 +8163,13 @@ impl RelayTransactionVecBuilder {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: RelayTransaction) -> Option<RelayTransaction> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<RelayTransaction>
+    where
+        T: ::core::convert::Into<RelayTransaction>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for RelayTransactionVecBuilder {
@@ -8192,8 +8483,11 @@ pub struct RelayTransactionsBuilder {
 }
 impl RelayTransactionsBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn transactions(mut self, v: RelayTransactionVec) -> Self {
-        self.transactions = v;
+    pub fn transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<RelayTransactionVec>,
+    {
+        self.transactions = v.into();
         self
     }
 }
@@ -8425,8 +8719,11 @@ pub struct RelayTransactionHashesBuilder {
 }
 impl RelayTransactionHashesBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn tx_hashes(mut self, v: Byte32Vec) -> Self {
-        self.tx_hashes = v;
+    pub fn tx_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.tx_hashes = v.into();
         self
     }
 }
@@ -8658,8 +8955,11 @@ pub struct GetRelayTransactionsBuilder {
 }
 impl GetRelayTransactionsBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn tx_hashes(mut self, v: Byte32Vec) -> Self {
-        self.tx_hashes = v;
+    pub fn tx_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.tx_hashes = v.into();
         self
     }
 }
@@ -8929,16 +9229,25 @@ pub struct GetBlockTransactionsBuilder {
 }
 impl GetBlockTransactionsBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn block_hash(mut self, v: Byte32) -> Self {
-        self.block_hash = v;
+    pub fn block_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.block_hash = v.into();
         self
     }
-    pub fn indexes(mut self, v: Uint32Vec) -> Self {
-        self.indexes = v;
+    pub fn indexes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32Vec>,
+    {
+        self.indexes = v.into();
         self
     }
-    pub fn uncle_indexes(mut self, v: Uint32Vec) -> Self {
-        self.uncle_indexes = v;
+    pub fn uncle_indexes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32Vec>,
+    {
+        self.uncle_indexes = v.into();
         self
     }
 }
@@ -9217,16 +9526,25 @@ pub struct BlockTransactionsBuilder {
 }
 impl BlockTransactionsBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn block_hash(mut self, v: Byte32) -> Self {
-        self.block_hash = v;
+    pub fn block_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.block_hash = v.into();
         self
     }
-    pub fn transactions(mut self, v: TransactionVec) -> Self {
-        self.transactions = v;
+    pub fn transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<TransactionVec>,
+    {
+        self.transactions = v.into();
         self
     }
-    pub fn uncles(mut self, v: UncleBlockVec) -> Self {
-        self.uncles = v;
+    pub fn uncles<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<UncleBlockVec>,
+    {
+        self.uncles = v.into();
         self
     }
 }
@@ -9488,12 +9806,18 @@ pub struct GetBlockProposalBuilder {
 }
 impl GetBlockProposalBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn block_hash(mut self, v: Byte32) -> Self {
-        self.block_hash = v;
+    pub fn block_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.block_hash = v.into();
         self
     }
-    pub fn proposals(mut self, v: ProposalShortIdVec) -> Self {
-        self.proposals = v;
+    pub fn proposals<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<ProposalShortIdVec>,
+    {
+        self.proposals = v.into();
         self
     }
 }
@@ -9730,8 +10054,11 @@ pub struct BlockProposalBuilder {
 }
 impl BlockProposalBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn transactions(mut self, v: TransactionVec) -> Self {
-        self.transactions = v;
+    pub fn transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<TransactionVec>,
+    {
+        self.transactions = v.into();
         self
     }
 }
@@ -9985,12 +10312,18 @@ pub struct IndexTransactionBuilder {
 }
 impl IndexTransactionBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn index(mut self, v: Uint32) -> Self {
-        self.index = v;
+    pub fn index<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.index = v.into();
         self
     }
-    pub fn transaction(mut self, v: Transaction) -> Self {
-        self.transaction = v;
+    pub fn transaction<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Transaction>,
+    {
+        self.transaction = v.into();
         self
     }
 }
@@ -10254,8 +10587,11 @@ impl IndexTransactionVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: IndexTransaction) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<IndexTransaction>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = IndexTransaction>>(
@@ -10265,10 +10601,13 @@ impl IndexTransactionVecBuilder {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: IndexTransaction) -> Option<IndexTransaction> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<IndexTransaction>
+    where
+        T: ::core::convert::Into<IndexTransaction>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for IndexTransactionVecBuilder {
@@ -11002,8 +11341,11 @@ 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(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
 }
@@ -11265,16 +11607,25 @@ pub struct BlockFiltersBuilder {
 }
 impl BlockFiltersBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn start_number(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
-    pub fn block_hashes(mut self, v: Byte32Vec) -> Self {
-        self.block_hashes = v;
+    pub fn block_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.block_hashes = v.into();
         self
     }
-    pub fn filters(mut self, v: BytesVec) -> Self {
-        self.filters = v;
+    pub fn filters<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesVec>,
+    {
+        self.filters = v.into();
         self
     }
 }
@@ -11438,8 +11789,11 @@ 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(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
 }
@@ -11722,16 +12076,25 @@ pub struct BlockFilterHashesBuilder {
 }
 impl BlockFilterHashesBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn start_number(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
-    pub fn parent_block_filter_hash(mut self, v: Byte32) -> Self {
-        self.parent_block_filter_hash = v;
+    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();
         self
     }
-    pub fn block_filter_hashes(mut self, v: Byte32Vec) -> Self {
-        self.block_filter_hashes = v;
+    pub fn block_filter_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.block_filter_hashes = v.into();
         self
     }
 }
@@ -11896,8 +12259,11 @@ 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(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
 }
@@ -12151,12 +12517,18 @@ pub struct BlockFilterCheckPointsBuilder {
 }
 impl BlockFilterCheckPointsBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn start_number(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
-    pub fn block_filter_hashes(mut self, v: Byte32Vec) -> Self {
-        self.block_filter_hashes = v;
+    pub fn block_filter_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.block_filter_hashes = v.into();
         self
     }
 }
@@ -12840,12 +13212,18 @@ pub struct GetHeadersBuilder {
 }
 impl GetHeadersBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn hash_stop(mut self, v: Byte32) -> Self {
-        self.hash_stop = v;
+    pub fn hash_stop<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.hash_stop = v.into();
         self
     }
-    pub fn block_locator_hashes(mut self, v: Byte32Vec) -> Self {
-        self.block_locator_hashes = v;
+    pub fn block_locator_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.block_locator_hashes = v.into();
         self
     }
 }
@@ -13082,8 +13460,11 @@ pub struct GetBlocksBuilder {
 }
 impl GetBlocksBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn block_hashes(mut self, v: Byte32Vec) -> Self {
-        self.block_hashes = v;
+    pub fn block_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.block_hashes = v.into();
         self
     }
 }
@@ -13315,8 +13696,11 @@ pub struct SendHeadersBuilder {
 }
 impl SendHeadersBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn headers(mut self, v: HeaderVec) -> Self {
-        self.headers = v;
+    pub fn headers<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderVec>,
+    {
+        self.headers = v.into();
         self
     }
 }
@@ -13558,8 +13942,11 @@ pub struct SendBlockBuilder {
 }
 impl SendBlockBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn block(mut self, v: Block) -> Self {
-        self.block = v;
+    pub fn block<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Block>,
+    {
+        self.block = v.into();
         self
     }
 }
@@ -13854,20 +14241,32 @@ pub struct FilteredBlockBuilder {
 }
 impl FilteredBlockBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn witnesses_root(mut self, v: Byte32) -> Self {
-        self.witnesses_root = v;
+    pub fn witnesses_root<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.witnesses_root = v.into();
         self
     }
-    pub fn transactions(mut self, v: TransactionVec) -> Self {
-        self.transactions = v;
+    pub fn transactions<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<TransactionVec>,
+    {
+        self.transactions = v.into();
         self
     }
-    pub fn proof(mut self, v: MerkleProof) -> Self {
-        self.proof = v;
+    pub fn proof<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<MerkleProof>,
+    {
+        self.proof = v.into();
         self
     }
 }
@@ -14132,12 +14531,18 @@ pub struct MerkleProofBuilder {
 }
 impl MerkleProofBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn indices(mut self, v: Uint32Vec) -> Self {
-        self.indices = v;
+    pub fn indices<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32Vec>,
+    {
+        self.indices = v.into();
         self
     }
-    pub fn lemmas(mut self, v: Byte32Vec) -> Self {
-        self.lemmas = v;
+    pub fn lemmas<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.lemmas = v.into();
         self
     }
 }
@@ -14535,18 +14940,24 @@ impl HeaderDigestVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: HeaderDigest) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigest>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = HeaderDigest>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: HeaderDigest) -> Option<HeaderDigest> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<HeaderDigest>
+    where
+        T: ::core::convert::Into<HeaderDigest>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for HeaderDigestVecBuilder {
@@ -14897,20 +15308,32 @@ pub struct VerifiableHeaderBuilder {
 }
 impl VerifiableHeaderBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn header(mut self, v: Header) -> Self {
-        self.header = v;
+    pub fn header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Header>,
+    {
+        self.header = v.into();
         self
     }
-    pub fn uncles_hash(mut self, v: Byte32) -> Self {
-        self.uncles_hash = v;
+    pub fn uncles_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.uncles_hash = v.into();
         self
     }
-    pub fn extension(mut self, v: BytesOpt) -> Self {
-        self.extension = v;
+    pub fn extension<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.extension = v.into();
         self
     }
-    pub fn parent_chain_root(mut self, v: HeaderDigest) -> Self {
-        self.parent_chain_root = v;
+    pub fn parent_chain_root<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigest>,
+    {
+        self.parent_chain_root = v.into();
         self
     }
 }
@@ -15182,8 +15605,11 @@ impl VerifiableHeaderVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: VerifiableHeader) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = VerifiableHeader>>(
@@ -15193,10 +15619,13 @@ impl VerifiableHeaderVecBuilder {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: VerifiableHeader) -> Option<VerifiableHeader> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<VerifiableHeader>
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for VerifiableHeaderVecBuilder {
@@ -15537,18 +15966,24 @@ impl FilteredBlockVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: FilteredBlock) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<FilteredBlock>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = FilteredBlock>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: FilteredBlock) -> Option<FilteredBlock> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<FilteredBlock>
+    where
+        T: ::core::convert::Into<FilteredBlock>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for FilteredBlockVecBuilder {
@@ -16407,8 +16842,11 @@ pub struct GetLastStateBuilder {
 }
 impl GetLastStateBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn subscribe(mut self, v: Bool) -> Self {
-        self.subscribe = v;
+    pub fn subscribe<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bool>,
+    {
+        self.subscribe = v.into();
         self
     }
 }
@@ -16654,8 +17092,11 @@ pub struct SendLastStateBuilder {
 }
 impl SendLastStateBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
-        self.last_header = v;
+    pub fn last_header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.last_header = v.into();
         self
     }
 }
@@ -16989,28 +17430,46 @@ pub struct GetLastStateProofBuilder {
 }
 impl GetLastStateProofBuilder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn last_hash(mut self, v: Byte32) -> Self {
-        self.last_hash = v;
+    pub fn last_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.last_hash = v.into();
         self
     }
-    pub fn start_hash(mut self, v: Byte32) -> Self {
-        self.start_hash = v;
+    pub fn start_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.start_hash = v.into();
         self
     }
-    pub fn start_number(mut self, v: Uint64) -> Self {
-        self.start_number = v;
+    pub fn start_number<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.start_number = v.into();
         self
     }
-    pub fn last_n_blocks(mut self, v: Uint64) -> Self {
-        self.last_n_blocks = v;
+    pub fn last_n_blocks<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.last_n_blocks = v.into();
         self
     }
-    pub fn difficulty_boundary(mut self, v: Uint256) -> Self {
-        self.difficulty_boundary = v;
+    pub fn difficulty_boundary<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint256>,
+    {
+        self.difficulty_boundary = v.into();
         self
     }
-    pub fn difficulties(mut self, v: Uint256Vec) -> Self {
-        self.difficulties = v;
+    pub fn difficulties<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint256Vec>,
+    {
+        self.difficulties = v.into();
         self
     }
 }
@@ -17313,16 +17772,25 @@ pub struct SendLastStateProofBuilder {
 }
 impl SendLastStateProofBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
-        self.last_header = v;
+    pub fn last_header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.last_header = v.into();
         self
     }
-    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
-        self.proof = v;
+    pub fn proof<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigestVec>,
+    {
+        self.proof = v.into();
         self
     }
-    pub fn headers(mut self, v: VerifiableHeaderVec) -> Self {
-        self.headers = v;
+    pub fn headers<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeaderVec>,
+    {
+        self.headers = v.into();
         self
     }
 }
@@ -17584,12 +18052,18 @@ pub struct GetBlocksProofBuilder {
 }
 impl GetBlocksProofBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn last_hash(mut self, v: Byte32) -> Self {
-        self.last_hash = v;
+    pub fn last_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.last_hash = v.into();
         self
     }
-    pub fn block_hashes(mut self, v: Byte32Vec) -> Self {
-        self.block_hashes = v;
+    pub fn block_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.block_hashes = v.into();
         self
     }
 }
@@ -17903,20 +18377,32 @@ pub struct SendBlocksProofBuilder {
 }
 impl SendBlocksProofBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
-        self.last_header = v;
+    pub fn last_header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.last_header = v.into();
         self
     }
-    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
-        self.proof = v;
+    pub fn proof<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigestVec>,
+    {
+        self.proof = v.into();
         self
     }
-    pub fn headers(mut self, v: HeaderVec) -> Self {
-        self.headers = v;
+    pub fn headers<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderVec>,
+    {
+        self.headers = v.into();
         self
     }
-    pub fn missing_block_hashes(mut self, v: Byte32Vec) -> Self {
-        self.missing_block_hashes = v;
+    pub fn missing_block_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.missing_block_hashes = v.into();
         self
     }
 }
@@ -18283,28 +18769,46 @@ pub struct SendBlocksProofV1Builder {
 }
 impl SendBlocksProofV1Builder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
-        self.last_header = v;
+    pub fn last_header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.last_header = v.into();
         self
     }
-    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
-        self.proof = v;
+    pub fn proof<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigestVec>,
+    {
+        self.proof = v.into();
         self
     }
-    pub fn headers(mut self, v: HeaderVec) -> Self {
-        self.headers = v;
+    pub fn headers<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderVec>,
+    {
+        self.headers = v.into();
         self
     }
-    pub fn missing_block_hashes(mut self, v: Byte32Vec) -> Self {
-        self.missing_block_hashes = v;
+    pub fn missing_block_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.missing_block_hashes = v.into();
         self
     }
-    pub fn blocks_uncles_hash(mut self, v: Byte32Vec) -> Self {
-        self.blocks_uncles_hash = v;
+    pub fn blocks_uncles_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.blocks_uncles_hash = v.into();
         self
     }
-    pub fn blocks_extension(mut self, v: BytesOptVec) -> Self {
-        self.blocks_extension = v;
+    pub fn blocks_extension<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOptVec>,
+    {
+        self.blocks_extension = v.into();
         self
     }
 }
@@ -18578,12 +19082,18 @@ pub struct GetTransactionsProofBuilder {
 }
 impl GetTransactionsProofBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn last_hash(mut self, v: Byte32) -> Self {
-        self.last_hash = v;
+    pub fn last_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32>,
+    {
+        self.last_hash = v.into();
         self
     }
-    pub fn tx_hashes(mut self, v: Byte32Vec) -> Self {
-        self.tx_hashes = v;
+    pub fn tx_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.tx_hashes = v.into();
         self
     }
 }
@@ -18887,20 +19397,32 @@ pub struct SendTransactionsProofBuilder {
 }
 impl SendTransactionsProofBuilder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
-        self.last_header = v;
+    pub fn last_header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.last_header = v.into();
         self
     }
-    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
-        self.proof = v;
+    pub fn proof<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigestVec>,
+    {
+        self.proof = v.into();
         self
     }
-    pub fn filtered_blocks(mut self, v: FilteredBlockVec) -> Self {
-        self.filtered_blocks = v;
+    pub fn filtered_blocks<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<FilteredBlockVec>,
+    {
+        self.filtered_blocks = v.into();
         self
     }
-    pub fn missing_tx_hashes(mut self, v: Byte32Vec) -> Self {
-        self.missing_tx_hashes = v;
+    pub fn missing_tx_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.missing_tx_hashes = v.into();
         self
     }
 }
@@ -19257,28 +19779,46 @@ pub struct SendTransactionsProofV1Builder {
 }
 impl SendTransactionsProofV1Builder {
     pub const FIELD_COUNT: usize = 6;
-    pub fn last_header(mut self, v: VerifiableHeader) -> Self {
-        self.last_header = v;
+    pub fn last_header<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<VerifiableHeader>,
+    {
+        self.last_header = v.into();
         self
     }
-    pub fn proof(mut self, v: HeaderDigestVec) -> Self {
-        self.proof = v;
+    pub fn proof<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<HeaderDigestVec>,
+    {
+        self.proof = v.into();
         self
     }
-    pub fn filtered_blocks(mut self, v: FilteredBlockVec) -> Self {
-        self.filtered_blocks = v;
+    pub fn filtered_blocks<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<FilteredBlockVec>,
+    {
+        self.filtered_blocks = v.into();
         self
     }
-    pub fn missing_tx_hashes(mut self, v: Byte32Vec) -> Self {
-        self.missing_tx_hashes = v;
+    pub fn missing_tx_hashes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.missing_tx_hashes = v.into();
         self
     }
-    pub fn blocks_uncles_hash(mut self, v: Byte32Vec) -> Self {
-        self.blocks_uncles_hash = v;
+    pub fn blocks_uncles_hash<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte32Vec>,
+    {
+        self.blocks_uncles_hash = v.into();
         self
     }
-    pub fn blocks_extension(mut self, v: BytesOptVec) -> Self {
-        self.blocks_extension = v;
+    pub fn blocks_extension<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOptVec>,
+    {
+        self.blocks_extension = v.into();
         self
     }
 }
@@ -19531,8 +20071,11 @@ pub struct TimeBuilder {
 }
 impl TimeBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn timestamp(mut self, v: Uint64) -> Self {
-        self.timestamp = v;
+    pub fn timestamp<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.timestamp = v.into();
         self
     }
 }
@@ -19870,32 +20413,53 @@ pub struct RawAlertBuilder {
 }
 impl RawAlertBuilder {
     pub const FIELD_COUNT: usize = 7;
-    pub fn notice_until(mut self, v: Uint64) -> Self {
-        self.notice_until = v;
+    pub fn notice_until<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.notice_until = v.into();
         self
     }
-    pub fn id(mut self, v: Uint32) -> Self {
-        self.id = v;
+    pub fn id<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.id = v.into();
         self
     }
-    pub fn cancel(mut self, v: Uint32) -> Self {
-        self.cancel = v;
+    pub fn cancel<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.cancel = v.into();
         self
     }
-    pub fn priority(mut self, v: Uint32) -> Self {
-        self.priority = v;
+    pub fn priority<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.priority = v.into();
         self
     }
-    pub fn message(mut self, v: Bytes) -> Self {
-        self.message = v;
+    pub fn message<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.message = v.into();
         self
     }
-    pub fn min_version(mut self, v: BytesOpt) -> Self {
-        self.min_version = v;
+    pub fn min_version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.min_version = v.into();
         self
     }
-    pub fn max_version(mut self, v: BytesOpt) -> Self {
-        self.max_version = v;
+    pub fn max_version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesOpt>,
+    {
+        self.max_version = v.into();
         self
     }
 }
@@ -20174,12 +20738,18 @@ pub struct AlertBuilder {
 }
 impl AlertBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn raw(mut self, v: RawAlert) -> Self {
-        self.raw = v;
+    pub fn raw<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<RawAlert>,
+    {
+        self.raw = v.into();
         self
     }
-    pub fn signatures(mut self, v: BytesVec) -> Self {
-        self.signatures = v;
+    pub fn signatures<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesVec>,
+    {
+        self.signatures = v.into();
         self
     }
 }
@@ -20454,16 +21024,25 @@ pub struct IdentifyBuilder {
 }
 impl IdentifyBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn flag(mut self, v: Uint64) -> Self {
-        self.flag = v;
+    pub fn flag<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.flag = v.into();
         self
     }
-    pub fn name(mut self, v: Bytes) -> Self {
-        self.name = v;
+    pub fn name<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.name = v.into();
         self
     }
-    pub fn client_version(mut self, v: Bytes) -> Self {
-        self.client_version = v;
+    pub fn client_version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.client_version = v.into();
         self
     }
 }
diff --git a/util/gen-types/src/generated/protocols.rs b/util/gen-types/src/generated/protocols.rs
index 97b1370233..797c57b804 100644
--- a/util/gen-types/src/generated/protocols.rs
+++ b/util/gen-types/src/generated/protocols.rs
@@ -513,8 +513,11 @@ pub struct PingMessageBuilder {
 }
 impl PingMessageBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn payload(mut self, v: PingPayload) -> Self {
-        self.payload = v;
+    pub fn payload<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<PingPayload>,
+    {
+        self.payload = v.into();
         self
     }
 }
@@ -746,8 +749,11 @@ pub struct PingBuilder {
 }
 impl PingBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn nonce(mut self, v: Uint32) -> Self {
-        self.nonce = v;
+    pub fn nonce<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.nonce = v.into();
         self
     }
 }
@@ -979,8 +985,11 @@ pub struct PongBuilder {
 }
 impl PongBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn nonce(mut self, v: Uint32) -> Self {
-        self.nonce = v;
+    pub fn nonce<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.nonce = v.into();
         self
     }
 }
@@ -1239,18 +1248,24 @@ impl NodeVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Node) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Node>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Node>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Node) -> Option<Node> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Node>
+    where
+        T: ::core::convert::Into<Node>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for NodeVecBuilder {
@@ -1587,18 +1602,24 @@ impl Node2VecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Node2) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Node2>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Node2>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Node2) -> Option<Node2> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Node2>
+    where
+        T: ::core::convert::Into<Node2>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for Node2VecBuilder {
@@ -1851,16 +1872,25 @@ impl Uint16Builder {
     pub const TOTAL_SIZE: usize = 2;
     pub const ITEM_SIZE: usize = 1;
     pub const ITEM_COUNT: usize = 2;
-    pub fn set(mut self, v: [Byte; 2]) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<[Byte; 2]>,
+    {
+        self.0 = v.into();
         self
     }
-    pub fn nth0(mut self, v: Byte) -> Self {
-        self.0[0] = v;
+    pub fn nth0<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[0] = v.into();
         self
     }
-    pub fn nth1(mut self, v: Byte) -> Self {
-        self.0[1] = v;
+    pub fn nth1<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Byte>,
+    {
+        self.0[1] = v.into();
         self
     }
 }
@@ -2067,8 +2097,11 @@ impl<'r> molecule::prelude::Reader<'r> for PortOptReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct PortOptBuilder(pub(crate) Option<Uint16>);
 impl PortOptBuilder {
-    pub fn set(mut self, v: Option<Uint16>) -> Self {
-        self.0 = v;
+    pub fn set<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Option<Uint16>>,
+    {
+        self.0 = v.into();
         self
     }
 }
@@ -2612,8 +2645,11 @@ pub struct DiscoveryMessageBuilder {
 }
 impl DiscoveryMessageBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn payload(mut self, v: DiscoveryPayload) -> Self {
-        self.payload = v;
+    pub fn payload<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<DiscoveryPayload>,
+    {
+        self.payload = v.into();
         self
     }
 }
@@ -2882,16 +2918,25 @@ pub struct GetNodesBuilder {
 }
 impl GetNodesBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn version(mut self, v: Uint32) -> Self {
-        self.version = v;
+    pub fn version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.version = v.into();
         self
     }
-    pub fn count(mut self, v: Uint32) -> Self {
-        self.count = v;
+    pub fn count<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.count = v.into();
         self
     }
-    pub fn listen_port(mut self, v: PortOpt) -> Self {
-        self.listen_port = v;
+    pub fn listen_port<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<PortOpt>,
+    {
+        self.listen_port = v.into();
         self
     }
 }
@@ -3187,20 +3232,32 @@ pub struct GetNodes2Builder {
 }
 impl GetNodes2Builder {
     pub const FIELD_COUNT: usize = 4;
-    pub fn version(mut self, v: Uint32) -> Self {
-        self.version = v;
+    pub fn version<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.version = v.into();
         self
     }
-    pub fn count(mut self, v: Uint32) -> Self {
-        self.count = v;
+    pub fn count<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint32>,
+    {
+        self.count = v.into();
         self
     }
-    pub fn listen_port(mut self, v: PortOpt) -> Self {
-        self.listen_port = v;
+    pub fn listen_port<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<PortOpt>,
+    {
+        self.listen_port = v.into();
         self
     }
-    pub fn required_flags(mut self, v: Uint64) -> Self {
-        self.required_flags = v;
+    pub fn required_flags<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.required_flags = v.into();
         self
     }
 }
@@ -3463,12 +3520,18 @@ pub struct NodesBuilder {
 }
 impl NodesBuilder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn announce(mut self, v: Bool) -> Self {
-        self.announce = v;
+    pub fn announce<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bool>,
+    {
+        self.announce = v.into();
         self
     }
-    pub fn items(mut self, v: NodeVec) -> Self {
-        self.items = v;
+    pub fn items<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<NodeVec>,
+    {
+        self.items = v.into();
         self
     }
 }
@@ -3723,12 +3786,18 @@ pub struct Nodes2Builder {
 }
 impl Nodes2Builder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn announce(mut self, v: Bool) -> Self {
-        self.announce = v;
+    pub fn announce<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bool>,
+    {
+        self.announce = v.into();
         self
     }
-    pub fn items(mut self, v: Node2Vec) -> Self {
-        self.items = v;
+    pub fn items<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Node2Vec>,
+    {
+        self.items = v.into();
         self
     }
 }
@@ -3965,8 +4034,11 @@ pub struct NodeBuilder {
 }
 impl NodeBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn addresses(mut self, v: BytesVec) -> Self {
-        self.addresses = v;
+    pub fn addresses<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesVec>,
+    {
+        self.addresses = v.into();
         self
     }
 }
@@ -4218,12 +4290,18 @@ pub struct Node2Builder {
 }
 impl Node2Builder {
     pub const FIELD_COUNT: usize = 2;
-    pub fn addresses(mut self, v: BytesVec) -> Self {
-        self.addresses = v;
+    pub fn addresses<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<BytesVec>,
+    {
+        self.addresses = v.into();
         self
     }
-    pub fn flags(mut self, v: Uint64) -> Self {
-        self.flags = v;
+    pub fn flags<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Uint64>,
+    {
+        self.flags = v.into();
         self
     }
 }
@@ -4487,18 +4565,24 @@ impl AddressVecBuilder {
         self.0 = v;
         self
     }
-    pub fn push(mut self, v: Address) -> Self {
-        self.0.push(v);
+    pub fn push<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Address>,
+    {
+        self.0.push(v.into());
         self
     }
     pub fn extend<T: ::core::iter::IntoIterator<Item = Address>>(mut self, iter: T) -> Self {
         self.0.extend(iter);
         self
     }
-    pub fn replace(&mut self, index: usize, v: Address) -> Option<Address> {
+    pub fn replace<T>(&mut self, index: usize, v: T) -> Option<Address>
+    where
+        T: ::core::convert::Into<Address>,
+    {
         self.0
             .get_mut(index)
-            .map(|item| ::core::mem::replace(item, v))
+            .map(|item| ::core::mem::replace(item, v.into()))
     }
 }
 impl molecule::prelude::Builder for AddressVecBuilder {
@@ -4808,8 +4892,11 @@ pub struct AddressBuilder {
 }
 impl AddressBuilder {
     pub const FIELD_COUNT: usize = 1;
-    pub fn bytes(mut self, v: Bytes) -> Self {
-        self.bytes = v;
+    pub fn bytes<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.bytes = v.into();
         self
     }
 }
@@ -5079,16 +5166,25 @@ pub struct IdentifyMessageBuilder {
 }
 impl IdentifyMessageBuilder {
     pub const FIELD_COUNT: usize = 3;
-    pub fn listen_addrs(mut self, v: AddressVec) -> Self {
-        self.listen_addrs = v;
+    pub fn listen_addrs<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<AddressVec>,
+    {
+        self.listen_addrs = v.into();
         self
     }
-    pub fn observed_addr(mut self, v: Address) -> Self {
-        self.observed_addr = v;
+    pub fn observed_addr<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Address>,
+    {
+        self.observed_addr = v.into();
         self
     }
-    pub fn identify(mut self, v: Bytes) -> Self {
-        self.identify = v;
+    pub fn identify<T>(mut self, v: T) -> Self
+    where
+        T: ::core::convert::Into<Bytes>,
+    {
+        self.identify = v.into();
         self
     }
 }
diff --git a/util/indexer/src/indexer.rs b/util/indexer/src/indexer.rs
index 6b87fd4378..cbbbc53859 100644
--- a/util/indexer/src/indexer.rs
+++ b/util/indexer/src/indexer.rs
@@ -938,7 +938,7 @@ mod tests {
             capacity_bytes, BlockBuilder, Capacity, EpochNumberWithFraction, HeaderBuilder,
             ScriptHashType, TransactionBuilder,
         },
-        packed::{CellInput, CellOutputBuilder, OutPoint, ScriptBuilder},
+        packed::{self, 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()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -983,40 +983,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1)
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2)
-                    .type_(Some(type_script2).into())
+                    .type_(Some(type_script2))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).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()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1066,40 +1066,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1108,35 +1108,35 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2)
-                    .type_(Some(type_script2).into())
+                    .type_(Some(type_script2))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -1145,12 +1145,13 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1.into())
+                    .number(1)
                     .parent_hash(block0.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        block0.number() + 1,
+                        block0.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
@@ -1199,27 +1200,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("consume_output_in_same_block");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1227,40 +1228,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0.clone())
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1269,47 +1270,47 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx12 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx11.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2).into())
+                    .type_(Some(type_script2))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -1319,12 +1320,13 @@ mod tests {
             .transaction(tx12)
             .header(
                 HeaderBuilder::default()
-                    .number(1.into())
+                    .number(1)
                     .parent_hash(block0.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        block0.number() + 1,
+                        block0.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
@@ -1371,27 +1373,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1399,40 +1401,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1445,35 +1447,35 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()).into())
+                        .type_(Some(type_script1.clone()))
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_tx1 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000).into())
+                        .capacity(capacity_bytes!(2000))
                         .lock(lock_script2.clone())
-                        .type_(Some(type_script2.clone()).into())
+                        .type_(Some(type_script2.clone()))
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_block = BlockBuilder::default()
@@ -1482,16 +1484,13 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).into())
+                        .number(pre_block.number() + 1)
                         .parent_hash(pre_block.hash())
-                        .epoch(
-                            EpochNumberWithFraction::new(
-                                pre_block.number() + 1,
-                                pre_block.number(),
-                                1000,
-                            )
-                            .into(),
-                        )
+                        .epoch(EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        ))
                         .build(),
                 )
                 .build();
@@ -1526,9 +1525,9 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("prune");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1536,16 +1535,16 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1558,27 +1557,24 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_block = BlockBuilder::default()
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).into())
+                        .number(pre_block.number() + 1)
                         .parent_hash(pre_block.hash())
-                        .epoch(
-                            EpochNumberWithFraction::new(
-                                pre_block.number() + 1,
-                                pre_block.number(),
-                                1000,
-                            )
-                            .into(),
-                        )
+                        .epoch(EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        ))
                         .build(),
                 )
                 .build();
@@ -1598,27 +1594,27 @@ mod tests {
         let indexer = new_indexer::<RocksdbStore>("append_and_rollback_with_cellbase");
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1626,40 +1622,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1)
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2)
-                    .type_(Some(type_script2).into())
+                    .type_(Some(type_script2))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1682,14 +1678,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]).into())
-            .hash_type(ScriptHashType::Data.into())
+            .code_hash(H256([0; 32]))
+            .hash_type(ScriptHashType::Data)
             .build();
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1697,16 +1693,16 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(all_zero_lock_script.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1728,27 +1724,24 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_block = BlockBuilder::default()
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).into())
+                        .number(pre_block.number() + 1)
                         .parent_hash(pre_block.hash())
-                        .epoch(
-                            EpochNumberWithFraction::new(
-                                pre_block.number() + 1,
-                                pre_block.number(),
-                                1000,
-                            )
-                            .into(),
-                        )
+                        .epoch(EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        ))
                         .build(),
                 )
                 .build();
@@ -1778,8 +1771,8 @@ mod tests {
                 .transaction(cellbase)
                 .header(
                     HeaderBuilder::default()
-                        .number(i.into())
-                        .epoch(EpochNumberWithFraction::new(i + 1, i, 1000).into())
+                        .number(i)
+                        .epoch(EpochNumberWithFraction::new(i + 1, i, 1000))
                         .build(),
                 )
                 .build();
@@ -1804,15 +1797,15 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1820,28 +1813,28 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0.clone())
             .transaction(tx00.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
         indexer.append(&block0).unwrap();
 
@@ -1850,23 +1843,23 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -1874,12 +1867,13 @@ mod tests {
             .transaction(tx10)
             .header(
                 HeaderBuilder::default()
-                    .number(1.into())
+                    .number(1)
                     .parent_hash(block0.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        block0.number() + 1,
+                        block0.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
@@ -1958,27 +1952,27 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1986,40 +1980,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
         indexer.append(&block0).unwrap();
         let (tip_number, tip_hash) = indexer.tip().unwrap().unwrap();
@@ -2031,35 +2025,35 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2)
-                    .type_(Some(type_script2).into())
+                    .type_(Some(type_script2))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -2068,12 +2062,13 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1.into())
+                    .number(1)
                     .parent_hash(block0.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        block0.number() + 1,
+                        block0.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
@@ -2126,27 +2121,27 @@ mod tests {
         );
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -2154,40 +2149,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
         indexer.append(&block0).unwrap();
         let (tip_number, tip_hash) = indexer.tip().unwrap().unwrap();
@@ -2213,35 +2208,35 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx10 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx11 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2)
-                    .type_(Some(type_script2).into())
+                    .type_(Some(type_script2))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block1 = BlockBuilder::default()
@@ -2250,12 +2245,13 @@ mod tests {
             .transaction(tx11)
             .header(
                 HeaderBuilder::default()
-                    .number(1.into())
+                    .number(1)
                     .parent_hash(block0.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000)
-                            .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        block0.number() + 1,
+                        block0.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
diff --git a/util/indexer/src/service.rs b/util/indexer/src/service.rs
index 13fb68f821..ab594b0c62 100644
--- a/util/indexer/src/service.rs
+++ b/util/indexer/src/service.rs
@@ -954,27 +954,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script2".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script2 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"type_script2".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"type_script2".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -982,40 +982,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1028,35 +1028,35 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Bytes::from(i.to_string()).into())
+                .output_data(Bytes::from(i.to_string()))
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()).into())
+                        .type_(Some(type_script1.clone()))
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_tx1 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000).into())
+                        .capacity(capacity_bytes!(2000))
                         .lock(lock_script2.clone())
-                        .type_(Some(type_script2.clone()).into())
+                        .type_(Some(type_script2.clone()))
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_block = BlockBuilder::default()
@@ -1065,16 +1065,13 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).into())
+                        .number(pre_block.number() + 1)
                         .parent_hash(pre_block.hash())
-                        .epoch(
-                            EpochNumberWithFraction::new(
-                                pre_block.number() + 1,
-                                pre_block.number(),
-                                1000,
-                            )
-                            .into(),
-                        )
+                        .epoch(EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        ))
                         .build(),
                 )
                 .build();
@@ -1476,12 +1473,12 @@ mod tests {
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
         pool.write().unwrap().new_transaction(&pool_tx);
 
@@ -1542,27 +1539,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script11 = ScriptBuilder::default()
             .code_hash(lock_script1.code_hash())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script11".to_vec()).into())
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script11".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script11 = ScriptBuilder::default()
             .code_hash(type_script1.code_hash())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script11".to_vec()).into())
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script11".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1570,40 +1567,40 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11.clone()).into())
+                    .type_(Some(type_script11.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00.clone())
             .transaction(tx01.clone())
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
@@ -1616,35 +1613,35 @@ mod tests {
                 .witness(Script::default().into_witness())
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
                         .build(),
                 )
-                .output_data(Bytes::from(i.to_string()).into())
+                .output_data(Bytes::from(i.to_string()))
                 .build();
 
             pre_tx0 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(1000).into())
+                        .capacity(capacity_bytes!(1000))
                         .lock(lock_script1.clone())
-                        .type_(Some(type_script1.clone()).into())
+                        .type_(Some(type_script1.clone()))
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_tx1 = TransactionBuilder::default()
                 .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
                 .output(
                     CellOutputBuilder::default()
-                        .capacity(capacity_bytes!(2000).into())
+                        .capacity(capacity_bytes!(2000))
                         .lock(lock_script11.clone())
-                        .type_(Some(type_script11.clone()).into())
+                        .type_(Some(type_script11.clone()))
                         .build(),
                 )
-                .output_data(Default::default())
+                .output_data(packed::Bytes::default())
                 .build();
 
             pre_block = BlockBuilder::default()
@@ -1653,16 +1650,13 @@ mod tests {
                 .transaction(pre_tx1.clone())
                 .header(
                     HeaderBuilder::default()
-                        .number((pre_block.number() + 1).into())
+                        .number(pre_block.number() + 1)
                         .parent_hash(pre_block.hash())
-                        .epoch(
-                            EpochNumberWithFraction::new(
-                                pre_block.number() + 1,
-                                pre_block.number(),
-                                1000,
-                            )
-                            .into(),
-                        )
+                        .epoch(EpochNumberWithFraction::new(
+                            pre_block.number() + 1,
+                            pre_block.number(),
+                            1000,
+                        ))
                         .build(),
                 )
                 .build();
@@ -1787,9 +1781,9 @@ mod tests {
         };
 
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).pack())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).pack())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
         let data = [0u8; 7];
         let res = rpc.get_cells(
@@ -1821,27 +1815,27 @@ mod tests {
 
         // setup test data
         let lock_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script1".to_vec()))
             .build();
 
         let lock_script11 = ScriptBuilder::default()
             .code_hash(lock_script1.code_hash())
-            .hash_type(ScriptHashType::Type.into())
-            .args(Bytes::from(b"lock_script11".to_vec()).into())
+            .hash_type(ScriptHashType::Type)
+            .args(Bytes::from(b"lock_script11".to_vec()))
             .build();
 
         let type_script1 = ScriptBuilder::default()
-            .code_hash(H256(rand::random()).into())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script1".to_vec()).into())
+            .code_hash(H256(rand::random()))
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script1".to_vec()))
             .build();
 
         let type_script11 = ScriptBuilder::default()
             .code_hash(type_script1.code_hash())
-            .hash_type(ScriptHashType::Data.into())
-            .args(Bytes::from(b"type_script11".to_vec()).into())
+            .hash_type(ScriptHashType::Data)
+            .args(Bytes::from(b"type_script11".to_vec()))
             .build();
 
         let cellbase0 = TransactionBuilder::default()
@@ -1849,22 +1843,22 @@ mod tests {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let tx00 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1)
-                    .type_(Some(type_script1).into())
+                    .type_(Some(type_script1))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         let mut data = [0u8; 7];
@@ -1872,19 +1866,19 @@ mod tests {
         let tx01 = TransactionBuilder::default()
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11).into())
+                    .type_(Some(type_script11))
                     .build(),
             )
-            .output_data(data.to_vec().into())
+            .output_data(data.to_vec())
             .build();
 
         let block0 = BlockBuilder::default()
             .transaction(cellbase0)
             .transaction(tx00)
             .transaction(tx01)
-            .header(HeaderBuilder::default().number(0.into()).build())
+            .header(HeaderBuilder::default().number(0).build())
             .build();
 
         indexer.append(&block0).unwrap();
diff --git a/util/jsonrpc-types/src/alert.rs b/util/jsonrpc-types/src/alert.rs
index 7c10afc782..5331da39ba 100644
--- a/util/jsonrpc-types/src/alert.rs
+++ b/util/jsonrpc-types/src/alert.rs
@@ -86,13 +86,13 @@ impl From<Alert> for packed::Alert {
             signatures,
         } = json;
         let raw = packed::RawAlert::new_builder()
-            .id(id.into())
-            .cancel(cancel.into())
-            .min_version(min_version.into())
-            .max_version(max_version.into())
-            .priority(priority.into())
-            .notice_until(notice_until.into())
-            .message(message.into())
+            .id(id)
+            .cancel(cancel)
+            .min_version(min_version)
+            .max_version(max_version)
+            .priority(priority)
+            .notice_until(notice_until)
+            .message(message)
             .build();
         packed::Alert::new_builder()
             .raw(raw)
@@ -100,8 +100,7 @@ impl From<Alert> for packed::Alert {
                 signatures
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::Bytes>>()
-                    .into(),
+                    .collect::<Vec<packed::Bytes>>(),
             )
             .build()
     }
diff --git a/util/jsonrpc-types/src/block_template.rs b/util/jsonrpc-types/src/block_template.rs
index 908abc66e5..d2ab354f8a 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.into())
-            .compact_target(compact_target.into())
-            .parent_hash(parent_hash.into())
-            .timestamp(current_time.into())
-            .number(number.into())
-            .epoch(epoch.into())
-            .dao(dao.into())
+            .version(version)
+            .compact_target(compact_target)
+            .parent_hash(parent_hash)
+            .timestamp(current_time)
+            .number(number)
+            .epoch(epoch)
+            .dao(dao)
             .build();
         let header = packed::Header::new_builder().raw(raw).build();
         let txs = packed::TransactionVec::new_builder()
-            .push(cellbase.into())
+            .push(cellbase)
             .extend(transactions.into_iter().map(|tx| tx.into()))
             .build();
         if let Some(extension) = extension {
@@ -136,16 +136,14 @@ impl From<BlockTemplate> for packed::Block {
                     uncles
                         .into_iter()
                         .map(|u| u.into())
-                        .collect::<Vec<packed::UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<packed::UncleBlock>>(),
                 )
                 .transactions(txs)
                 .proposals(
                     proposals
                         .into_iter()
                         .map(|p| p.into())
-                        .collect::<Vec<packed::ProposalShortId>>()
-                        .into(),
+                        .collect::<Vec<packed::ProposalShortId>>(),
                 )
                 .extension(extension)
                 .build()
@@ -157,16 +155,14 @@ impl From<BlockTemplate> for packed::Block {
                     uncles
                         .into_iter()
                         .map(|u| u.into())
-                        .collect::<Vec<packed::UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<packed::UncleBlock>>(),
                 )
                 .transactions(txs)
                 .proposals(
                     proposals
                         .into_iter()
                         .map(|p| p.into())
-                        .collect::<Vec<packed::ProposalShortId>>()
-                        .into(),
+                        .collect::<Vec<packed::ProposalShortId>>(),
                 )
                 .build()
         }
@@ -197,13 +193,12 @@ impl From<UncleTemplate> for packed::UncleBlock {
             proposals, header, ..
         } = template;
         packed::UncleBlock::new_builder()
-            .header(header.into())
+            .header(header)
             .proposals(
                 proposals
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::ProposalShortId>>()
-                    .into(),
+                    .collect::<Vec<packed::ProposalShortId>>(),
             )
             .build()
     }
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index b9b0a15c9b..409ff1ad21 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().into())
-            .code_hash(code_hash.into())
-            .hash_type(hash_type.into())
+            .args(args.into_bytes())
+            .code_hash(code_hash)
+            .hash_type(hash_type)
             .build()
     }
 }
@@ -182,8 +182,8 @@ impl From<CellOutput> for packed::CellOutput {
         }
         .build();
         packed::CellOutput::new_builder()
-            .capacity(capacity.into())
-            .lock(lock.into())
+            .capacity(capacity)
+            .lock(lock)
             .type_(type_)
             .build()
     }
@@ -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.into())
-            .index(index.into())
+            .tx_hash(tx_hash)
+            .index(index)
             .build()
     }
 }
@@ -273,8 +273,8 @@ impl From<CellInput> for packed::CellInput {
             since,
         } = json;
         packed::CellInput::new_builder()
-            .previous_output(previous_output.into())
-            .since(since.into())
+            .previous_output(previous_output)
+            .since(since)
             .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.into())
-            .dep_type(dep_type.into())
+            .out_point(out_point)
+            .dep_type(dep_type)
             .build()
     }
 }
@@ -506,41 +506,36 @@ impl From<Transaction> for packed::Transaction {
             outputs_data,
         } = json;
         let raw = packed::RawTransaction::new_builder()
-            .version(version.into())
+            .version(version)
             .cell_deps(
                 cell_deps
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::CellDep>>()
-                    .into(),
+                    .collect::<Vec<packed::CellDep>>(),
             )
             .header_deps(
                 header_deps
                     .iter()
                     .map(Pack::pack)
-                    .collect::<Vec<packed::Byte32>>()
-                    .into(),
+                    .collect::<Vec<packed::Byte32>>(),
             )
             .inputs(
                 inputs
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::CellInput>>()
-                    .into(),
+                    .collect::<Vec<packed::CellInput>>(),
             )
             .outputs(
                 outputs
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::CellOutput>>()
-                    .into(),
+                    .collect::<Vec<packed::CellOutput>>(),
             )
             .outputs_data(
                 outputs_data
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::Bytes>>()
-                    .into(),
+                    .collect::<Vec<packed::Bytes>>(),
             )
             .build();
         packed::Transaction::new_builder()
@@ -549,8 +544,7 @@ impl From<Transaction> for packed::Transaction {
                 witnesses
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::Bytes>>()
-                    .into(),
+                    .collect::<Vec<packed::Bytes>>(),
             )
             .build()
     }
@@ -867,21 +861,18 @@ impl From<Header> for packed::Header {
             nonce,
         } = json;
         let raw = packed::RawHeader::new_builder()
-            .version(version.into())
-            .parent_hash(parent_hash.into())
-            .timestamp(timestamp.into())
-            .number(number.into())
-            .epoch(epoch.into())
-            .transactions_root(transactions_root.into())
-            .proposals_hash(proposals_hash.into())
-            .compact_target(compact_target.into())
-            .extra_hash(extra_hash.into())
-            .dao(dao.into())
+            .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)
             .build();
-        packed::Header::new_builder()
-            .raw(raw)
-            .nonce(nonce.into())
-            .build()
+        packed::Header::new_builder().raw(raw).nonce(nonce).build()
     }
 }
 
@@ -957,13 +948,12 @@ impl From<UncleBlock> for packed::UncleBlock {
     fn from(json: UncleBlock) -> Self {
         let UncleBlock { header, proposals } = json;
         packed::UncleBlock::new_builder()
-            .header(header.into())
+            .header(header)
             .proposals(
                 proposals
                     .into_iter()
                     .map(Into::into)
-                    .collect::<Vec<packed::ProposalShortId>>()
-                    .into(),
+                    .collect::<Vec<packed::ProposalShortId>>(),
             )
             .build()
     }
@@ -1119,54 +1109,48 @@ impl From<Block> for packed::Block {
         if let Some(extension) = extension {
             let extension: packed::Bytes = extension.into();
             packed::BlockV1::new_builder()
-                .header(header.into())
+                .header(header)
                 .uncles(
                     uncles
                         .into_iter()
                         .map(Into::into)
-                        .collect::<Vec<packed::UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<packed::UncleBlock>>(),
                 )
                 .transactions(
                     transactions
                         .into_iter()
                         .map(Into::into)
-                        .collect::<Vec<packed::Transaction>>()
-                        .into(),
+                        .collect::<Vec<packed::Transaction>>(),
                 )
                 .proposals(
                     proposals
                         .into_iter()
                         .map(Into::into)
-                        .collect::<Vec<packed::ProposalShortId>>()
-                        .into(),
+                        .collect::<Vec<packed::ProposalShortId>>(),
                 )
                 .extension(extension)
                 .build()
                 .as_v0()
         } else {
             packed::Block::new_builder()
-                .header(header.into())
+                .header(header)
                 .uncles(
                     uncles
                         .into_iter()
                         .map(Into::into)
-                        .collect::<Vec<packed::UncleBlock>>()
-                        .into(),
+                        .collect::<Vec<packed::UncleBlock>>(),
                 )
                 .transactions(
                     transactions
                         .into_iter()
                         .map(Into::into)
-                        .collect::<Vec<packed::Transaction>>()
-                        .into(),
+                        .collect::<Vec<packed::Transaction>>(),
                 )
                 .proposals(
                     proposals
                         .into_iter()
                         .map(Into::into)
-                        .collect::<Vec<packed::ProposalShortId>>()
-                        .into(),
+                        .collect::<Vec<packed::ProposalShortId>>(),
                 )
                 .build()
         }
diff --git a/util/jsonrpc-types/src/tests/blockchain.rs b/util/jsonrpc-types/src/tests/blockchain.rs
index 2a2fefe79b..eb217947b2 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.into())
-        .hash_type(core::ScriptHashType::Data.into())
+        .args(arg)
+        .hash_type(core::ScriptHashType::Data)
         .build()
 }
 
 fn mock_cell_output(arg: Bytes) -> packed::CellOutput {
     packed::CellOutputBuilder::default()
-        .capacity(core::Capacity::zero().into())
+        .capacity(core::Capacity::zero())
         .lock(packed::Script::default())
-        .type_(Some(mock_script(arg)).into())
+        .type_(Some(mock_script(arg)))
         .build()
 }
 
@@ -33,7 +33,7 @@ fn mock_full_tx(data: Bytes, arg: Bytes) -> core::TransactionView {
         .inputs(vec![mock_cell_input()])
         .outputs(vec![mock_cell_output(arg.clone())])
         .outputs_data(vec![data.into()])
-        .witness(arg.into())
+        .witness(arg)
         .build()
 }
 
diff --git a/util/launcher/Cargo.toml b/util/launcher/Cargo.toml
index 5a04b7bfe9..934bd9fce9 100644
--- a/util/launcher/Cargo.toml
+++ b/util/launcher/Cargo.toml
@@ -11,7 +11,6 @@ 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.118.0-pre" }
 ckb-store = { path = "../../store", version = "= 0.118.0-pre" }
 ckb-app-config = { path = "../app-config", version = "= 0.118.0-pre" }
 ckb-logger = { path = "../logger", version = "= 0.118.0-pre" }
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 1d74a1fd02..61540b8bef 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(Into::into(extension))
+                    .extension(extension)
                     .parent_chain_root(parent_chain_root)
                     .build();
 
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 e0e7a71f5d..715cf01a85 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.into())
+                .transactions(txs)
                 .proof(
                     packed::MerkleProof::new_builder()
-                        .indices(merkle_proof.indices().into())
-                        .lemmas(merkle_proof.lemmas().to_owned().into())
+                        .indices(merkle_proof.indices())
+                        .lemmas(merkle_proof.lemmas().to_owned())
                         .build(),
                 )
                 .build();
diff --git a/util/light-client-protocol-server/src/lib.rs b/util/light-client-protocol-server/src/lib.rs
index d049ee3953..94be3c0b53 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(Into::into(tip_block.extension()))
+            .extension(tip_block.extension())
             .parent_chain_root(parent_chain_root)
             .build();
 
@@ -206,7 +206,7 @@ impl LightClientProtocol {
         let verifiable_last_header = packed::VerifiableHeader::new_builder()
             .header(last_block.data().header())
             .uncles_hash(last_block.calc_uncles_hash())
-            .extension(Into::into(last_block.extension()))
+            .extension(last_block.extension())
             .parent_chain_root(parent_chain_root)
             .build();
         let content = T::new_builder()
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 e17fbfb4cf..981fda9250 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
@@ -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.into())
+            .block_hashes(request_block_hashes)
             .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 693f032442..dc50c27bf0 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.into())
-            .last_n_blocks(10u64.into())
-            .difficulty_boundary(genesis_header.difficulty().into())
+            .start_number(0u64)
+            .last_n_blocks(10u64)
+            .difficulty_boundary(genesis_header.difficulty())
             .build();
         packed::LightClientMessage::new_builder()
             .set(content)
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 b70a1db9c1..021872d962 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
@@ -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()].into())
+            .tx_hashes(vec![tx1.hash(), tx2.hash(), tx3_hash.into()])
             .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 1e578f2712..2b35b8a7b6 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(Into::into(block.extension()))
+                .extension(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 289b36bb75..a88239dac6 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.into())
+            .output_data(always_success_cell_data)
             .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().into())
-                .compact_target(DIFF_TWO.into())
+                .timestamp(unix_time_as_millis())
+                .compact_target(DIFF_TWO)
                 .transaction(always_success_tx)
                 .dao(dao)
                 .build();
@@ -202,7 +202,7 @@ impl MockChain {
         let header_dep = block.hash();
         let (_, _, always_success_script) = always_success_cell();
         let output = packed::CellOutput::new_builder()
-            .capacity(output_capacity.into())
+            .capacity(output_capacity)
             .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(Default::default())
+            .output_data(packed::Bytes::default())
             .build()
     }
 }
diff --git a/util/migrate/src/migrations/cell.rs b/util/migrate/src/migrations/cell.rs
index f01d80012b..9d83c802cc 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.into())
+                        .index(index)
                         .build();
 
                     let entry = packed::CellEntryBuilder::default()
                         .output(cell_output)
                         .block_hash(block_hash.clone())
-                        .block_number(block_number.into())
-                        .block_epoch(block_epoch.into())
-                        .index(tx_index.into())
-                        .data_size((data.len() as u64).into())
+                        .block_number(block_number)
+                        .block_epoch(block_epoch)
+                        .index(tx_index)
+                        .data_size(data.len() as u64)
                         .build();
 
                     let data_entry = if !data.is_empty() {
                         let data_hash = packed::CellOutput::calc_data_hash(&data);
                         Some(
                             packed::CellDataEntryBuilder::default()
-                                .output_data(data.into())
+                                .output_data(data)
                                 .output_data_hash(data_hash)
                                 .build(),
                         )
diff --git a/util/migrate/src/tests.rs b/util/migrate/src/tests.rs
index 93b41cf8e8..eda61099cd 100644
--- a/util/migrate/src/tests.rs
+++ b/util/migrate/src/tests.rs
@@ -65,7 +65,7 @@ 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.into())
+                .index(index)
                 .build();
             let tx_data: packed::TransactionView = tx.into();
             db_txn
diff --git a/util/network-alert/src/tests/generate_alert_signature.rs b/util/network-alert/src/tests/generate_alert_signature.rs
index 028b65a1c7..77a8a3f808 100644
--- a/util/network-alert/src/tests/generate_alert_signature.rs
+++ b/util/network-alert/src/tests/generate_alert_signature.rs
@@ -25,13 +25,13 @@ 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.into())
-        .id(20230001u32.into())
-        .cancel(0u32.into())
-        .priority(20u32.into())
-        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.".into())
-        .min_version(Some("0.105.0-pre").into())
-        .max_version(Some("0.105.1").into())
+        .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"))
         .build();
 
     let hash = raw_alert.calc_alert_hash();
@@ -43,7 +43,7 @@ fn test_signing_alert_using_dummy_keypair() {
         .into();
     let alert = packed::Alert::new_builder()
         .raw(raw_alert)
-        .signatures(vec![signature.clone()].into())
+        .signatures(vec![signature.clone()])
         .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.into())
-        .id(20230001u32.into())
-        .cancel(0u32.into())
-        .priority(20u32.into())
-        .message("CKB v0.105.* have bugs. Please upgrade to the latest version.".into())
-        .min_version(Some("0.105.0-pre").into())
-        .max_version(Some("0.105.1").into())
+        .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"))
         .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.into()
+        buf
     }).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 ea0654861a..7d6d97329e 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.into())
-        .cancel(cancel.into())
-        .min_version(min_ver.into())
-        .max_version(max_ver.into())
-        .notice_until(notice_until.into())
+        .id(id)
+        .cancel(cancel)
+        .min_version(min_ver)
+        .max_version(max_ver)
+        .notice_until(notice_until)
         .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 0b86c88b21..1a0c3d8d60 100644
--- a/util/network-alert/src/tests/test_verifier.rs
+++ b/util/network-alert/src/tests/test_verifier.rs
@@ -15,7 +15,7 @@ fn test_veirifer() {
             .collect(),
     };
     let verifier = Verifier::new(config);
-    let raw_alert = packed::RawAlert::new_builder().id(1u32.into()).build();
+    let raw_alert = packed::RawAlert::new_builder().id(1u32).build();
     let hash = raw_alert.calc_alert_hash();
     let signatures = keypairs
         .iter()
@@ -23,7 +23,7 @@ fn test_veirifer() {
         .collect::<Result<Vec<_>, _>>()
         .expect("sign alert")
         .iter()
-        .map(|sig| sig.serialize().into())
+        .map(|sig| sig.serialize())
         .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 72b2494f7d..0df6e50116 100644
--- a/util/reward-calculator/src/tests.rs
+++ b/util/reward-calculator/src/tests.rs
@@ -128,12 +128,12 @@ fn test_proposal_reward() {
         .tx_proposal_window(ProposalWindow(2, 5))
         .build();
 
-    let tx1 = TransactionBuilder::default().version(100u32.into()).build();
-    let tx2 = TransactionBuilder::default().version(200u32.into()).build();
-    let tx3 = TransactionBuilder::default().version(300u32.into()).build();
-    let tx4 = TransactionBuilder::default().version(400u32.into()).build();
-    let tx5 = TransactionBuilder::default().version(500u32.into()).build();
-    let tx6 = TransactionBuilder::default().version(600u32.into()).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 p1 = tx1.proposal_short_id();
     let p2 = tx2.proposal_short_id();
@@ -145,8 +145,8 @@ fn test_proposal_reward() {
     let block_10 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(10u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 10, 1000).into())
+                .number(10u64)
+                .epoch(EpochNumberWithFraction::new(1, 10, 1000))
                 .build(),
         )
         .proposal(p1.clone())
@@ -159,8 +159,8 @@ fn test_proposal_reward() {
     let block_11 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(11u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 11, 1000).into())
+                .number(11u64)
+                .epoch(EpochNumberWithFraction::new(1, 11, 1000))
                 .parent_hash(block_10.hash())
                 .build(),
         )
@@ -171,8 +171,8 @@ fn test_proposal_reward() {
     let block_12 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(12u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 12, 1000).into())
+                .number(12u64)
+                .epoch(EpochNumberWithFraction::new(1, 12, 1000))
                 .parent_hash(block_11.hash())
                 .build(),
         )
@@ -182,8 +182,8 @@ fn test_proposal_reward() {
     let block_13 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(13u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 13, 1000).into())
+                .number(13u64)
+                .epoch(EpochNumberWithFraction::new(1, 13, 1000))
                 .parent_hash(block_12.hash())
                 .build(),
         )
@@ -194,8 +194,8 @@ fn test_proposal_reward() {
     let block_14 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(14u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 14, 1000).into())
+                .number(14u64)
+                .epoch(EpochNumberWithFraction::new(1, 14, 1000))
                 .parent_hash(block_13.hash())
                 .build(),
         )
@@ -207,8 +207,8 @@ fn test_proposal_reward() {
     let block_15 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(15u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 15, 1000).into())
+                .number(15u64)
+                .epoch(EpochNumberWithFraction::new(1, 15, 1000))
                 .parent_hash(block_14.hash())
                 .build(),
         )
@@ -218,8 +218,8 @@ fn test_proposal_reward() {
     let block_16 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(16u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 16, 1000).into())
+                .number(16u64)
+                .epoch(EpochNumberWithFraction::new(1, 16, 1000))
                 .parent_hash(block_15.hash())
                 .build(),
         )
@@ -227,8 +227,8 @@ fn test_proposal_reward() {
     let block_17 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(17u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 17, 1000).into())
+                .number(17u64)
+                .epoch(EpochNumberWithFraction::new(1, 17, 1000))
                 .parent_hash(block_16.hash())
                 .build(),
         )
@@ -236,8 +236,8 @@ fn test_proposal_reward() {
     let block_18 = BlockBuilder::default()
         .header(
             HeaderBuilder::default()
-                .number(18u64.into())
-                .epoch(EpochNumberWithFraction::new(1, 18, 1000).into())
+                .number(18u64)
+                .epoch(EpochNumberWithFraction::new(1, 18, 1000))
                 .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 3fe3f19153..4ede859f26 100644
--- a/util/rich-indexer/src/indexer/insert.rs
+++ b/util/rich-indexer/src/indexer/insert.rs
@@ -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]).into());
+        lock_builder = lock_builder.code_hash(to_fixed_array::<32>(&lock_code_hash[0..32]));
     }
     if let Some(lock_args) = lock_args {
-        lock_builder = lock_builder.args(lock_args.into());
+        lock_builder = lock_builder.args(lock_args);
     }
     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]).into());
+        type_builder = type_builder.code_hash(to_fixed_array::<32>(&type_code_hash[0..32]));
     }
     if let Some(type_args) = type_args {
-        type_builder = type_builder.args(type_args.into());
+        type_builder = type_builder.args(type_args);
     }
     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).into())
+        .capacity(capacity as u64)
         .lock(lock_script)
-        .type_(Some(type_script).into())
+        .type_(Some(type_script))
         .build();
 
     Some((id, cell_output, data.into()))
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 efa7ecfe5c..9eb77805ba 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
@@ -249,28 +249,30 @@ 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")).into())
-        .index((row.get::<i32, _>("output_index") as u32).into())
+        .tx_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("tx_hash")))
+        .index(row.get::<i32, _>("output_index") as u32)
         .build();
     let lock_script = ScriptBuilder::default()
-        .code_hash(to_fixed_array::<32>(&row.get::<Vec<u8>, _>("lock_code_hash")).into())
-        .hash_type((row.get::<i16, _>("lock_hash_type") as u8).into())
-        .args(row.get::<Vec<u8>, _>("lock_args").into())
+        .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"))
         .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).into())
-                .hash_type((row.get::<Option<i16>, _>("type_hash_type").unwrap() as u8).into())
-                .args(row.get::<Option<Vec<u8>>, _>("type_args").unwrap().into())
+                .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())
                 .build()
         });
     let output = CellOutputBuilder::default()
-        .capacity((row.get::<i64, _>("capacity") as u64).into())
+        .capacity(row.get::<i64, _>("capacity") as u64)
         .lock(lock_script)
-        .type_(type_script.into())
+        .type_(type_script)
         .build();
 
     IndexerCell {
diff --git a/util/rich-indexer/src/tests/insert.rs b/util/rich-indexer/src/tests/insert.rs
index 2628a4e082..7980dd75a2 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::{CellInput, CellOutputBuilder, OutPoint, Script, ScriptBuilder},
+    packed::{self, 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()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"lock_script1".to_vec()))
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script2".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script2".to_vec()))
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script1".to_vec()))
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"type_script2".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"type_script2".to_vec()))
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -109,40 +109,40 @@ async fn with_custom_block_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).into())
+                .type_(Some(type_script1.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()).into())
+                .type_(Some(type_script2.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.into()).build())
+        .header(HeaderBuilder::default().number(0).build())
         .build();
     indexer.append(&block0).await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
@@ -154,35 +154,35 @@ async fn with_custom_block_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx10 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1).into())
+                .type_(Some(type_script1))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx11 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script2)
-                .type_(Some(type_script2).into())
+                .type_(Some(type_script2))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let block1 = BlockBuilder::default()
@@ -191,11 +191,13 @@ async fn with_custom_block_filter() {
         .transaction(tx11)
         .header(
             HeaderBuilder::default()
-                .number(1.into())
+                .number(1)
                 .parent_hash(block0.hash())
-                .epoch(
-                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).into(),
-                )
+                .epoch(EpochNumberWithFraction::new(
+                    block0.number() + 1,
+                    block0.number(),
+                    1000,
+                ))
                 .build(),
         )
         .build();
@@ -295,27 +297,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()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"lock_script1".to_vec()))
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script2".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script2".to_vec()))
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script1".to_vec()))
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"type_script2".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"type_script2".to_vec()))
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -323,40 +325,40 @@ async fn with_custom_cell_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).into())
+                .type_(Some(type_script1.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()).into())
+                .type_(Some(type_script2.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.into()).build())
+        .header(HeaderBuilder::default().number(0).build())
         .build();
     indexer.append(&block0).await.unwrap();
     let tip = indexer_handle.get_indexer_tip().await.unwrap().unwrap();
@@ -402,35 +404,35 @@ async fn with_custom_cell_filter() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx10 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx00.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1).into())
+                .type_(Some(type_script1))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx11 = TransactionBuilder::default()
         .input(CellInput::new(OutPoint::new(tx01.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script2)
-                .type_(Some(type_script2).into())
+                .type_(Some(type_script2))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let block1 = BlockBuilder::default()
@@ -439,11 +441,13 @@ async fn with_custom_cell_filter() {
         .transaction(tx11)
         .header(
             HeaderBuilder::default()
-                .number(1.into())
+                .number(1)
                 .parent_hash(block0.hash())
-                .epoch(
-                    EpochNumberWithFraction::new(block0.number() + 1, block0.number(), 1000).into(),
-                )
+                .epoch(EpochNumberWithFraction::new(
+                    block0.number() + 1,
+                    block0.number(),
+                    1000,
+                ))
                 .build(),
         )
         .build();
diff --git a/util/rich-indexer/src/tests/query.rs b/util/rich-indexer/src/tests/query.rs
index dfeee1a0f4..c67bc8d8be 100644
--- a/util/rich-indexer/src/tests/query.rs
+++ b/util/rich-indexer/src/tests/query.rs
@@ -44,15 +44,11 @@ async fn get_cells() {
     insert_blocks(pool.clone()).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(
-            hex::decode("62e907b15cbf27d5425399ebf6f0fb50ebb88f18")
-                .expect("Decoding failed")
-                .into(),
-        )
+        .code_hash(h256!(
+            "0x0000000000000000000000000000000000000000000000000000000000000000"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(hex::decode("62e907b15cbf27d5425399ebf6f0fb50ebb88f18").expect("Decoding failed"))
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.into(),
@@ -69,11 +65,11 @@ async fn get_cells() {
     assert_eq!(cells.objects.len(), 1);
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("62e907b15cbf").expect("Decoding failed").into())
+        .code_hash(h256!(
+            "0x0000000000000000000000000000000000000000000000000000000000000000"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(hex::decode("62e907b15cbf").expect("Decoding failed"))
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.into(),
@@ -116,22 +112,20 @@ async fn get_cells() {
     assert_eq!(cell.output_data, None);
 
     let type_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").into(),
-        )
-        .hash_type((ScriptHashType::Type as u8).into())
+        .code_hash(h256!(
+            "0x00000000000000000000000000000000000000000000000000545950455f4944"
+        ))
+        .hash_type(ScriptHashType::Type as u8)
         .args(
-            h256!("0xb2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626")
-                .as_bytes()
-                .into(),
+            h256!("0xb2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626").as_bytes(),
         )
         .build();
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(vec![].as_slice().into())
+        .code_hash(h256!(
+            "0x0000000000000000000000000000000000000000000000000000000000000000"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(vec![].as_slice())
         .build();
     let lock_script_len = extract_raw_data(&lock_script).len() as u64;
     let search_key = IndexerSearchKey {
@@ -174,14 +168,13 @@ async fn get_cells_filter_data() {
 
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
-            .code_hash(
-                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").into(),
-            )
-            .hash_type((ScriptHashType::Type as u8).into())
+            .code_hash(h256!(
+                "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            ))
+            .hash_type(ScriptHashType::Type as u8)
             .args(
                 hex::decode("b2a8500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bcf626")
-                    .expect("Decoding failed")
-                    .into(),
+                    .expect("Decoding failed"),
             )
             .build()
             .into(),
@@ -229,11 +222,11 @@ async fn get_cells_by_cursor() {
     insert_blocks(pool.clone()).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("").expect("Decoding failed").into())
+        .code_hash(h256!(
+            "0x0000000000000000000000000000000000000000000000000000000000000000"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(hex::decode("").expect("Decoding failed"))
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.clone().into(),
@@ -289,11 +282,11 @@ async fn get_transactions_ungrouped() {
     insert_blocks(pool).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("").expect("Decoding failed").into())
+        .code_hash(h256!(
+            "0x0000000000000000000000000000000000000000000000000000000000000000"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(hex::decode("").expect("Decoding failed"))
         .build();
 
     let search_key = IndexerSearchKey {
@@ -347,15 +340,11 @@ async fn get_transactions_ungrouped() {
     assert_eq!(7, txs.objects.len());
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x709f3fda12f561cfacf92273c57a98fede188a3f1a59b1f888d113f9cce08649").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(
-            hex::decode("b73961e46d9eb118d3de1d1e8f30b3af7bbf3160")
-                .expect("Decoding failed")
-                .into(),
-        )
+        .code_hash(h256!(
+            "0x709f3fda12f561cfacf92273c57a98fede188a3f1a59b1f888d113f9cce08649"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(hex::decode("b73961e46d9eb118d3de1d1e8f30b3af7bbf3160").expect("Decoding failed"))
         .build();
     let search_key = IndexerSearchKey {
         script: lock_script.clone().into(),
@@ -413,11 +402,11 @@ async fn get_transactions_grouped() {
     insert_blocks(pool).await;
 
     let lock_script = ScriptBuilder::default()
-        .code_hash(
-            h256!("0x0000000000000000000000000000000000000000000000000000000000000000").into(),
-        )
-        .hash_type((ScriptHashType::Data as u8).into())
-        .args(hex::decode("").expect("Decoding failed").into())
+        .code_hash(h256!(
+            "0x0000000000000000000000000000000000000000000000000000000000000000"
+        ))
+        .hash_type(ScriptHashType::Data as u8)
+        .args(hex::decode("").expect("Decoding failed"))
         .build();
 
     let search_key = IndexerSearchKey {
@@ -495,15 +484,11 @@ async fn get_cells_capacity() {
 
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
-            .code_hash(
-                h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8").into(),
-            )
-            .hash_type((ScriptHashType::Type as u8).into())
-            .args(
-                hex::decode("57ccb07be6875f61d93636b0ee11b675494627d2")
-                    .expect("Decoding failed")
-                    .into(),
-            )
+            .code_hash(h256!(
+                "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
+            ))
+            .hash_type(ScriptHashType::Type as u8)
+            .args(hex::decode("57ccb07be6875f61d93636b0ee11b675494627d2").expect("Decoding failed"))
             .build()
             .into(),
         script_type: IndexerScriptType::Lock,
@@ -526,14 +511,13 @@ async fn get_cells_capacity() {
 
     let search_key = IndexerSearchKey {
         script: ScriptBuilder::default()
-            .code_hash(
-                h256!("0x00000000000000000000000000000000000000000000000000545950455f4944").into(),
-            )
-            .hash_type((ScriptHashType::Type as u8).into())
+            .code_hash(h256!(
+                "0x00000000000000000000000000000000000000000000000000545950455f4944"
+            ))
+            .hash_type(ScriptHashType::Type as u8)
             .args(
                 hex::decode("500929d6a1294bf9bf1bf565f549fa4a5f1316a3306ad3d4783e64bc")
-                    .expect("Decoding failed")
-                    .into(),
+                    .expect("Decoding failed"),
             )
             .build()
             .into(),
@@ -564,27 +548,27 @@ async fn rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"lock_script1".to_vec()))
         .build();
 
     let lock_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script2".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script2".to_vec()))
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script1".to_vec()))
         .build();
 
     let type_script2 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"type_script2".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"type_script2".to_vec()))
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -592,40 +576,40 @@ async fn rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).into())
+                .type_(Some(type_script1.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script2.clone())
-                .type_(Some(type_script2.clone()).into())
+                .type_(Some(type_script2.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.into()).build())
+        .header(HeaderBuilder::default().number(0).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
@@ -638,35 +622,35 @@ async fn rpc() {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Bytes::from(i.to_string()).into())
+            .output_data(Bytes::from(i.to_string()))
             .build();
 
         pre_tx0 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         pre_tx1 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script2.clone())
-                    .type_(Some(type_script2.clone()).into())
+                    .type_(Some(type_script2.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         pre_block = BlockBuilder::default()
@@ -675,16 +659,13 @@ async fn rpc() {
             .transaction(pre_tx1.clone())
             .header(
                 HeaderBuilder::default()
-                    .number((pre_block.number() + 1).into())
+                    .number(pre_block.number() + 1)
                     .parent_hash(pre_block.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        )
-                        .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        pre_block.number() + 1,
+                        pre_block.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
@@ -1107,12 +1088,12 @@ async fn rpc() {
         .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1).into())
+                .type_(Some(type_script1))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
     pool.write().unwrap().new_transaction(&pool_tx);
 
@@ -1172,27 +1153,27 @@ async fn script_search_mode_rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script1".to_vec()))
         .build();
 
     let lock_script11 = ScriptBuilder::default()
         .code_hash(lock_script1.code_hash())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script11".to_vec()).into())
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script11".to_vec()))
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script1".to_vec()))
         .build();
 
     let type_script11 = ScriptBuilder::default()
         .code_hash(type_script1.code_hash())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script11".to_vec()).into())
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script11".to_vec()))
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -1200,40 +1181,40 @@ async fn script_search_mode_rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).into())
+                .type_(Some(type_script1.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script11.clone())
-                .type_(Some(type_script11.clone()).into())
+                .type_(Some(type_script11.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.into()).build())
+        .header(HeaderBuilder::default().number(0).build())
         .build();
 
     indexer.append(&block0).await.unwrap();
@@ -1246,35 +1227,35 @@ async fn script_search_mode_rpc() {
             .witness(Script::default().into_witness())
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
                     .build(),
             )
-            .output_data(Bytes::from(i.to_string()).into())
+            .output_data(Bytes::from(i.to_string()))
             .build();
 
         pre_tx0 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx0.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(1000).into())
+                    .capacity(capacity_bytes!(1000))
                     .lock(lock_script1.clone())
-                    .type_(Some(type_script1.clone()).into())
+                    .type_(Some(type_script1.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         pre_tx1 = TransactionBuilder::default()
             .input(CellInput::new(OutPoint::new(pre_tx1.hash(), 0), 0))
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity_bytes!(2000).into())
+                    .capacity(capacity_bytes!(2000))
                     .lock(lock_script11.clone())
-                    .type_(Some(type_script11.clone()).into())
+                    .type_(Some(type_script11.clone()))
                     .build(),
             )
-            .output_data(Default::default())
+            .output_data(packed::Bytes::default())
             .build();
 
         pre_block = BlockBuilder::default()
@@ -1283,16 +1264,13 @@ async fn script_search_mode_rpc() {
             .transaction(pre_tx1.clone())
             .header(
                 HeaderBuilder::default()
-                    .number((pre_block.number() + 1).into())
+                    .number(pre_block.number() + 1)
                     .parent_hash(pre_block.hash())
-                    .epoch(
-                        EpochNumberWithFraction::new(
-                            pre_block.number() + 1,
-                            pre_block.number(),
-                            1000,
-                        )
-                        .into(),
-                    )
+                    .epoch(EpochNumberWithFraction::new(
+                        pre_block.number() + 1,
+                        pre_block.number(),
+                        1000,
+                    ))
                     .build(),
             )
             .build();
@@ -1421,27 +1399,27 @@ async fn output_data_filter_mode_rpc() {
 
     // setup test data
     let lock_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script1".to_vec()))
         .build();
 
     let lock_script11 = ScriptBuilder::default()
         .code_hash(lock_script1.code_hash())
-        .hash_type(ScriptHashType::Type.into())
-        .args(Bytes::from(b"lock_script11".to_vec()).into())
+        .hash_type(ScriptHashType::Type)
+        .args(Bytes::from(b"lock_script11".to_vec()))
         .build();
 
     let type_script1 = ScriptBuilder::default()
-        .code_hash(H256(rand::random()).into())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script1".to_vec()).into())
+        .code_hash(H256(rand::random()))
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script1".to_vec()))
         .build();
 
     let type_script11 = ScriptBuilder::default()
         .code_hash(type_script1.code_hash())
-        .hash_type(ScriptHashType::Data.into())
-        .args(Bytes::from(b"type_script11".to_vec()).into())
+        .hash_type(ScriptHashType::Data)
+        .args(Bytes::from(b"type_script11".to_vec()))
         .build();
 
     let cellbase0 = TransactionBuilder::default()
@@ -1449,40 +1427,40 @@ async fn output_data_filter_mode_rpc() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx00 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1000).into())
+                .capacity(capacity_bytes!(1000))
                 .lock(lock_script1.clone())
-                .type_(Some(type_script1.clone()).into())
+                .type_(Some(type_script1.clone()))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let tx01 = TransactionBuilder::default()
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(2000).into())
+                .capacity(capacity_bytes!(2000))
                 .lock(lock_script11.clone())
-                .type_(Some(type_script11.clone()).into())
+                .type_(Some(type_script11.clone()))
                 .build(),
         )
-        .output_data(hex::decode("62e907b15cbf00aa00bbcc").unwrap().into())
+        .output_data(hex::decode("62e907b15cbf00aa00bbcc").unwrap())
         .build();
 
     let block0 = BlockBuilder::default()
         .transaction(cellbase0)
         .transaction(tx00.clone())
         .transaction(tx01.clone())
-        .header(HeaderBuilder::default().number(0.into()).build())
+        .header(HeaderBuilder::default().number(0).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 b9808007d2..9347ffce00 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().into())
+        .capacity(Capacity::bytes(data.len()).unwrap())
         .build();
 
     let script = Script::new_builder()
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data)
         .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.into())
+        .output_data(always_success_cell_data)
         .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.into())
-        .compact_target(difficulty_to_compact(U256::from(1000u64)).into())
+        .timestamp(GENESIS_TIMESTAMP)
+        .compact_target(difficulty_to_compact(U256::from(1000u64)))
         .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.into())
+            .capacity(reward)
             .lock(always_success_script.to_owned())
             .build();
 
-        builder.output(output).output_data(data.into()).build()
+        builder.output(output).output_data(data).build()
     }
 }
 
diff --git a/util/test-chain-utils/src/median_time.rs b/util/test-chain-utils/src/median_time.rs
index 55674c4179..95f625322f 100644
--- a/util/test-chain-utils/src/median_time.rs
+++ b/util/test-chain-utils/src/median_time.rs
@@ -48,16 +48,13 @@ impl MockMedianTime {
                     .map(|(idx, timestamp)| {
                         let number = idx as BlockNumber;
                         let header = HeaderBuilder::default()
-                            .timestamp(timestamp.into())
-                            .number(number.into())
-                            .epoch(
-                                EpochNumberWithFraction::new(
-                                    number % MOCK_EPOCH_LENGTH,
-                                    number / MOCK_EPOCH_LENGTH,
-                                    MOCK_EPOCH_LENGTH,
-                                )
-                                .into(),
-                            )
+                            .timestamp(timestamp)
+                            .number(number)
+                            .epoch(EpochNumberWithFraction::new(
+                                number % MOCK_EPOCH_LENGTH,
+                                number / MOCK_EPOCH_LENGTH,
+                                MOCK_EPOCH_LENGTH,
+                            ))
                             .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 bafd472491..874c09a96b 100644
--- a/util/test-chain-utils/src/mock_chain.rs
+++ b/util/test-chain-utils/src/mock_chain.rs
@@ -49,9 +49,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .compact_target(epoch.compact_target().into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .number(parent.number() + 1)
+            .compact_target(epoch.compact_target())
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
             .dao(dao)
             .transaction(cellbase)
             .proposals(txs.iter().map(TransactionView::proposal_short_id))
@@ -78,9 +78,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-            .compact_target(difficulty_to_compact(U256::from(difficulty)).into())
+            .number(parent.number() + 1)
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .compact_target(difficulty_to_compact(U256::from(difficulty)))
             .dao(dao)
             .transaction(cellbase)
             .proposals(ids)
@@ -102,9 +102,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-            .compact_target(difficulty_to_compact(U256::from(difficulty)).into())
+            .number(parent.number() + 1)
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .compact_target(difficulty_to_compact(U256::from(difficulty)))
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -126,9 +126,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .compact_target(difficulty_to_compact(difficulty + U256::from(inc)).into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .number(parent.number() + 1)
+            .compact_target(difficulty_to_compact(difficulty + U256::from(inc)))
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -149,10 +149,10 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .compact_target(epoch.compact_target().into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
-            .nonce(nonce.into())
+            .number(parent.number() + 1)
+            .compact_target(epoch.compact_target())
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
+            .nonce(nonce)
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -173,9 +173,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .compact_target(epoch.compact_target().into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .number(parent.number() + 1)
+            .compact_target(epoch.compact_target())
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
             .dao(dao)
             .transaction(cellbase)
             .build();
@@ -209,9 +209,9 @@ impl<'a> MockChain<'a> {
 
         let new_block = BlockBuilder::default()
             .parent_hash(parent.hash())
-            .number((parent.number() + 1).into())
-            .compact_target(epoch.compact_target().into())
-            .epoch(epoch.number_with_fraction(parent.number() + 1).into())
+            .number(parent.number() + 1)
+            .compact_target(epoch.compact_target())
+            .epoch(epoch.number_with_fraction(parent.number() + 1))
             .dao(dao)
             .transaction(cellbase)
             .transactions(txs)
diff --git a/util/test-chain-utils/src/mock_utils.rs b/util/test-chain-utils/src/mock_utils.rs
index fb0fb3b077..123b868a02 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.into())
+        .output_data(always_success_cell_data)
         .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.into())
+        .output_data(load_input_data_hash_cell_data)
         .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.into())
+        .output_data(load_input_one_byte_cell_data)
         .build()
 }
 
@@ -97,11 +97,11 @@ pub fn create_cellbase(
         builder
             .output(
                 CellOutputBuilder::default()
-                    .capacity(capacity.into())
+                    .capacity(capacity)
                     .lock(always_success_script.clone())
                     .build(),
             )
-            .output_data(Bytes::new().into())
+            .output_data(Bytes::new())
             .build()
     }
 }
@@ -139,7 +139,7 @@ pub fn create_multi_outputs_transaction(
             output_capacity
         };
         CellOutputBuilder::default()
-            .capacity(capacity.into())
+            .capacity(capacity)
             .lock(always_success_script.clone())
             .build()
     });
@@ -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).into())
+                .capacity(capacity_bytes!(100))
                 .lock(always_success_script.clone())
                 .build(),
         )
-        .output_data(data.into())
+        .output_data(data)
         .input(CellInput::new(out_point, 0))
         .cell_dep(
             CellDep::new_builder()
diff --git a/util/types/src/conversion/storage.rs b/util/types/src/conversion/storage.rs
index d238a7cfa4..50178a6da8 100644
--- a/util/types/src/conversion/storage.rs
+++ b/util/types/src/conversion/storage.rs
@@ -169,9 +169,9 @@ 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.pack())
+            .received_at(self.received_at)
             .total_difficulty(self.total_difficulty.pack())
-            .total_uncles_count(self.total_uncles_count.pack())
+            .total_uncles_count(self.total_uncles_count)
             .verified(self.verified.pack())
             .txs_fees((self.txs_fees[..]).pack())
             .cycles(self.cycles.pack())
@@ -189,13 +189,13 @@ impl From<core::BlockExt> for packed::BlockExtV1 {
 impl From<&core::BlockExt> for packed::BlockExtV1 {
     fn from(value: &core::BlockExt) -> Self {
         packed::BlockExtV1::new_builder()
-            .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.pack())
-            .txs_sizes((&value.txs_sizes).into())
+            .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()
     }
 }
@@ -233,14 +233,14 @@ 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().pack())
+            .number(self.number())
             .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().pack())
-            .length(self.length().pack())
-            .compact_target(self.compact_target().pack())
+            .start_number(self.start_number())
+            .length(self.length())
+            .compact_target(self.compact_target())
             .build()
     }
 }
@@ -254,14 +254,14 @@ impl From<core::EpochExt> for packed::EpochExt {
 impl From<&core::EpochExt> for packed::EpochExt {
     fn from(value: &core::EpochExt) -> Self {
         packed::EpochExt::new_builder()
-            .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())
+            .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().into())
-            .length(value.length().into())
-            .compact_target(value.compact_target().into())
+            .start_number(value.start_number())
+            .length(value.length())
+            .compact_target(value.compact_target())
             .build()
     }
 }
@@ -304,11 +304,11 @@ 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.pack())
+            .index(self.index)
             .build();
         packed::TransactionInfo::new_builder()
             .key(key)
-            .block_number(self.block_number.pack())
+            .block_number(self.block_number)
             .block_epoch(self.block_epoch.pack())
             .build()
     }
@@ -324,12 +324,12 @@ 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.into())
+            .index(value.index)
             .build();
         packed::TransactionInfo::new_builder()
             .key(key)
-            .block_number(value.block_number.into())
-            .block_epoch(value.block_epoch.into())
+            .block_number(value.block_number)
+            .block_epoch(value.block_epoch)
             .build()
     }
 }
diff --git a/util/types/src/core/advanced_builders.rs b/util/types/src/core/advanced_builders.rs
index eae6b39a9e..007fd57225 100644
--- a/util/types/src/core/advanced_builders.rs
+++ b/util/types/src/core/advanced_builders.rs
@@ -1,5 +1,7 @@
 //! Advanced builders for Transaction(View), Header(View) and Block(View).
 
+use ckb_gen_types::packed::{ProposalShortIdVec, UncleBlockVec};
+
 use crate::{
     constants, core, packed,
     prelude::*,
@@ -73,7 +75,7 @@ pub struct BlockBuilder {
 impl ::std::default::Default for TransactionBuilder {
     fn default() -> Self {
         Self {
-            version: constants::TX_VERSION.pack(),
+            version: constants::TX_VERSION.into(),
             cell_deps: Default::default(),
             header_deps: Default::default(),
             inputs: Default::default(),
@@ -87,15 +89,15 @@ impl ::std::default::Default for TransactionBuilder {
 impl ::std::default::Default for HeaderBuilder {
     fn default() -> Self {
         Self {
-            version: constants::BLOCK_VERSION.pack(),
+            version: constants::BLOCK_VERSION.into(),
             parent_hash: Default::default(),
             timestamp: Default::default(),
             number: Default::default(),
             transactions_root: Default::default(),
             proposals_hash: Default::default(),
-            compact_target: DIFF_TWO.pack(),
+            compact_target: DIFF_TWO.into(),
             extra_hash: Default::default(),
-            epoch: core::EpochNumberWithFraction::new_unchecked(0, 0, 0).pack(),
+            epoch: core::EpochNumberWithFraction::new_unchecked(0, 0, 0).into(),
             dao: Default::default(),
             nonce: Default::default(),
         }
@@ -109,15 +111,21 @@ 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(mut self, v: packed::$type) -> Self {
-            self.$prefix.$field = v;
+        pub fn $field<T>(mut self, v: T) -> Self
+        where
+            T: ::core::convert::Into<packed::$type>,
+        {
+            self.$prefix.$field = v.into();
             self
         }
     };
     (__add_doc, $field:ident, $type:ident, $comment:expr) => {
         #[doc = $comment]
-        pub fn $field(mut self, v: packed::$type) -> Self {
-            self.$field = v;
+        pub fn $field<T>(mut self, v: T) -> Self
+        where
+            T: ::core::convert::Into<packed::$type>,
+        {
+            self.$field = v.into();
             self
         }
     };
@@ -147,8 +155,11 @@ macro_rules! def_setter_for_vector {
         $comment_push:expr, $comment_extend:expr, $comment_set:expr,
     ) => {
         #[doc = $comment_push]
-        pub fn $func_push(mut self, v: $prefix::$type) -> Self {
-            self.$field.push(v);
+        pub fn $func_push<T>(mut self, v: T) -> Self
+        where
+            T: ::core::convert::Into<$prefix::$type>,
+        {
+            self.$field.push(v.into());
             self
         }
         #[doc = $comment_extend]
@@ -227,15 +238,15 @@ impl TransactionBuilder {
         } = self;
         let raw = packed::RawTransaction::new_builder()
             .version(version)
-            .cell_deps(cell_deps.pack())
-            .header_deps(header_deps.pack())
-            .inputs(inputs.pack())
-            .outputs(outputs.pack())
-            .outputs_data(outputs_data.pack())
+            .cell_deps(cell_deps)
+            .header_deps(header_deps)
+            .inputs(inputs)
+            .outputs(outputs)
+            .outputs_data(outputs_data)
             .build();
         let tx = packed::Transaction::new_builder()
             .raw(raw)
-            .witnesses(witnesses.pack())
+            .witnesses(witnesses)
             .build();
         let hash = tx.calc_tx_hash();
         let witness_hash = tx.calc_witness_hash();
@@ -276,12 +287,12 @@ impl HeaderBuilder {
             nonce,
         } = self;
         debug_assert!(
-            Unpack::<u32>::unpack(&compact_target) > 0,
+            Into::<u32>::into(&compact_target) > 0,
             "[HeaderBuilder] compact_target should greater than zero"
         );
         debug_assert!(
-            Unpack::<core::BlockNumber>::unpack(&number) == 0
-                || Unpack::<core::EpochNumberWithFraction>::unpack(&epoch).is_well_formed(),
+            Into::<core::BlockNumber>::into(&number) == 0
+                || Into::<core::EpochNumberWithFraction>::into(&epoch).is_well_formed(),
             "[HeaderBuilder] epoch {epoch:x} should be well formed, \
             unless it's in the genesis block (number: {number:x})"
         );
@@ -397,8 +408,8 @@ impl BlockBuilder {
                 )
         };
 
-        let proposals = proposals.pack();
-        let uncles = uncles.pack();
+        let proposals: ProposalShortIdVec = proposals.into();
+        let uncles: UncleBlockVec = uncles.into();
 
         let core::HeaderView { data, hash } = if reset_header {
             let raw_transactions_root = merkle_root(&tx_hashes[..]);
@@ -423,7 +434,7 @@ impl BlockBuilder {
             packed::BlockV1::new_builder()
                 .header(data)
                 .uncles(uncles)
-                .transactions(transactions.pack())
+                .transactions(transactions)
                 .proposals(proposals)
                 .extension(extension)
                 .build()
@@ -432,14 +443,14 @@ impl BlockBuilder {
             packed::Block::new_builder()
                 .header(data)
                 .uncles(uncles)
-                .transactions(transactions.pack())
+                .transactions(transactions)
                 .proposals(proposals)
                 .build()
         };
         core::BlockView {
             data: block,
             hash,
-            uncle_hashes: uncle_hashes.pack(),
+            uncle_hashes: uncle_hashes.into(),
             tx_hashes,
             tx_witness_hashes,
         }
diff --git a/util/types/src/core/cell.rs b/util/types/src/core/cell.rs
index e5b62499ab..ec77abf34d 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().unpack()
+        self.cell_output.capacity().into()
     }
 
     /// 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.into())
+                    .dep_type(DepType::DepGroup)
                     .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.into())
+                    .dep_type(DepType::Code)
                     .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().unpack();
+                let j: usize = out_point.index().into();
                 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().unpack()).map(|_| true))
+            .and_then(|outputs| outputs.get(out_point.index().into()).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().unpack())
+                .get(out_point.index().into())
                 .map(|cell| {
                     let data = tx
                         .outputs_data()
-                        .get(out_point.index().unpack())
+                        .get(out_point.index().into())
                         .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.into())
+        .dep_type(DepType::Code)
         .build();
 
     let dao_dep = CellDep::new_builder()
         .out_point(OutPoint::new(system_cell_transaction.hash(), 2))
-        .dep_type(DepType::Code.into())
+        .dep_type(DepType::Code)
         .build();
 
     let secp_data_dep = CellDep::new_builder()
         .out_point(OutPoint::new(system_cell_transaction.hash(), 3))
-        .dep_type(DepType::Code.into())
+        .dep_type(DepType::Code)
         .build();
 
     let secp_group_dep = CellDep::new_builder()
         .out_point(OutPoint::new(secp_cell_transaction.hash(), 0))
-        .dep_type(DepType::DepGroup.into())
+        .dep_type(DepType::DepGroup)
         .build();
 
     let multi_sign_secp_group = CellDep::new_builder()
         .out_point(OutPoint::new(secp_cell_transaction.hash(), 1))
-        .dep_type(DepType::DepGroup.into())
+        .dep_type(DepType::DepGroup)
         .build();
 
     let mut cell_deps = HashMap::new();
diff --git a/util/types/src/core/extras.rs b/util/types/src/core/extras.rs
index d42eb66ce6..4f401401c1 100644
--- a/util/types/src/core/extras.rs
+++ b/util/types/src/core/extras.rs
@@ -49,7 +49,7 @@ impl TransactionInfo {
     pub fn key(&self) -> packed::TransactionKey {
         packed::TransactionKey::new_builder()
             .block_hash(self.block_hash.clone())
-            .index(self.index.pack())
+            .index(self.index)
             .build()
     }
 
diff --git a/util/types/src/core/tests/cell.rs b/util/types/src/core/tests/cell.rs
index 28de967f24..cb17b78bab 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::{Byte32, CellDep, CellInput, CellOutput, OutPoint},
+    packed::{self, 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).pack())
+        .capacity(capacity_bytes!(2))
         .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").pack(), 1);
-    let op_2 = OutPoint::new(h256!("0x23").pack(), 2);
-    let op_3 = OutPoint::new(h256!("0x33").pack(), 3);
+    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);
 
     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 = vec![op_1.clone(), op_2.clone(), op_3.clone()]
-        .pack()
-        .as_bytes();
+    let cell_data =
+        Into::<packed::OutPointVec>::into(vec![op_1.clone(), op_2.clone(), op_3.clone()])
+            .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.into())
+        .dep_type(DepType::DepGroup)
         .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.into())
+        .dep_type(DepType::DepGroup)
         .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").pack(), 5);
+    let op_unknown = OutPoint::new(h256!("0x45").into(), 5);
     let op_dep = OutPoint::new(Byte32::zero(), 72);
-    let cell_data = vec![op_unknown.clone()].pack().as_bytes();
+    let cell_data = Into::<packed::OutPointVec>::into(vec![op_unknown.clone()]).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.into())
+        .dep_type(DepType::DepGroup)
         .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").pack();
-    let block_hash2 = h256!("0x2222").pack();
+    let block_hash1 = h256!("0x1111");
+    let block_hash2 = h256!("0x2222");
 
-    header_checker.push_attached(block_hash1.clone());
-    header_checker.push_attached(block_hash2.clone());
+    header_checker.push_attached(block_hash1.clone().into());
+    header_checker.push_attached(block_hash2.clone().into());
 
     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 = h256!("0xaabbcc").pack();
-    let invalid_block_hash = h256!("0x3344").pack();
+    let main_chain_block_hash: Byte32 = h256!("0xaabbcc").into();
+    let invalid_block_hash: Byte32 = h256!("0x3344").into();
 
     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").pack(), 3);
+    let out_point = OutPoint::new(h256!("0x2").into(), 3);
 
     let tx1 = TransactionBuilder::default()
         .input(CellInput::new(out_point, 0))
         .output(
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(2).pack())
+                .capacity(capacity_bytes!(2))
                 .build(),
         )
-        .output_data(Default::default())
+        .output_data(packed::Bytes::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").pack(), 3);
+    let out_point = OutPoint::new(h256!("0x2").into(), 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").pack(), 3);
+    let out_point = OutPoint::new(h256!("0x2").into(), 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 6a0d666dc4..7729cbe4d6 100644
--- a/util/types/src/core/tests/transaction_meta.rs
+++ b/util/types/src/core/tests/transaction_meta.rs
@@ -2,7 +2,6 @@ use crate::{
     core::{TransactionMeta, TransactionMetaBuilder},
     h256,
     packed::Byte32,
-    prelude::*,
 };
 
 #[test]
@@ -23,7 +22,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").pack();
+    let block_hash: Byte32 = h256!("0xf").into();
     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 d3c3aeb4de..ab00e1f600 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.pack())
-            .epoch(EpochNumberWithFraction::new(0, 1, 1000).pack())
+            .number(1u64)
+            .epoch(EpochNumberWithFraction::new(0, 1, 1000))
             .build()
             .as_uncle();
         let uncle2 = packed::Block::new_advanced_builder()
-            .number(2u64.pack())
-            .epoch(EpochNumberWithFraction::new(0, 2, 1000).pack())
+            .number(2u64)
+            .epoch(EpochNumberWithFraction::new(0, 2, 1000))
             .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].pack();
+    let extension: packed::Bytes = [0u8, 1, 2, 3, 4, 5, 6, 7].into();
     // 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 326751b3eb..146e1107e7 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().unpack(),
+            data().as_reader().raw().$field().into(),
             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().unpack(),
+            data().as_reader().header().raw().$field().into(),
             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().unpack(),
+            data().as_reader().header().raw().$field().into(),
             concat!("Gets `header.raw.", stringify!($field), "`.")
         );
     };
@@ -304,7 +304,7 @@ impl TransactionView {
 
     /// Gets `raw.version`.
     pub fn version(&self) -> Version {
-        self.data().raw().version().unpack()
+        self.data().raw().version().into()
     }
 
     /// 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.pack())
+            (extension_hash, ret.into())
         });
         Self {
             uncles_hash,
@@ -492,7 +492,7 @@ impl HeaderView {
 
     /// Gets `nonce`.
     pub fn nonce(&self) -> u128 {
-        self.data().nonce().unpack()
+        self.data().nonce().into()
     }
 
     /// 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().unpack()
+        self.data().header().nonce().into()
     }
 
     /// Gets `header`.
@@ -637,7 +637,7 @@ impl BlockView {
 
     /// Gets `header.nonce`.
     pub fn nonce(&self) -> u128 {
-        self.data().header().nonce().unpack()
+        self.data().header().nonce().into()
     }
 
     /// Gets `header.difficulty`.
@@ -824,7 +824,11 @@ impl BlockView {
     ) -> Self {
         let block = packed::Block::new_builder()
             .header(header.data())
-            .transactions(body.iter().map(|tx| tx.data()).pack())
+            .transactions(
+                body.iter()
+                    .map(|tx| tx.data())
+                    .collect::<Vec<packed::Transaction>>(),
+            )
             .uncles(uncles.data())
             .proposals(proposals)
             .build();
@@ -854,7 +858,11 @@ impl BlockView {
     ) -> Self {
         let block = packed::BlockV1::new_builder()
             .header(header.data())
-            .transactions(body.iter().map(|tx| tx.data()).pack())
+            .transactions(
+                body.iter()
+                    .map(|tx| tx.data())
+                    .collect::<Vec<packed::Transaction>>(),
+            )
             .uncles(uncles.data())
             .proposals(proposals)
             .extension(extension)
@@ -944,7 +952,8 @@ impl IntoBlockView for packed::Block {
             .uncles()
             .iter()
             .map(|uncle| uncle.calc_header_hash())
-            .pack();
+            .collect::<Vec<_>>()
+            .into();
         BlockView {
             data: block,
             hash,
diff --git a/util/types/src/extension.rs b/util/types/src/extension.rs
index 2711c8f90d..dbc7f2cc74 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().unpack())
+        compact_to_difficulty(self.compact_target().into())
     }
 }
 
@@ -86,7 +86,7 @@ impl BuildCompactBlock for packed::CompactBlock {
                 || transaction.is_cellbase()
             {
                 let prefilled_tx = packed::IndexTransaction::new_builder()
-                    .index((transaction_index as u32).pack())
+                    .index(transaction_index)
                     .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.pack())
-                .prefilled_transactions(prefilled_transactions.pack())
+                .short_ids(short_ids)
+                .prefilled_transactions(prefilled_transactions)
                 .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.pack())
-                .prefilled_transactions(prefilled_transactions.pack())
+                .short_ids(short_ids)
+                .prefilled_transactions(prefilled_transactions)
                 .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().unpack())
+            .map(|tx_index| tx_index.index().into())
             .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().unpack());
+            .map(|i| i.index().into());
 
         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.pack());
+        assert_eq!(block.calc_extra_hash().extra_hash(), expect.into());
     }
 }
diff --git a/util/types/src/utilities/merkle_mountain_range.rs b/util/types/src/utilities/merkle_mountain_range.rs
index 2f8a9d71b4..7cd37afb96 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().pack())
+            .total_difficulty(self.difficulty())
             .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().unpack();
-        let end_number: BlockNumber = self.end_number().unpack();
+        let start_number: BlockNumber = self.start_number().into();
+        let end_number: BlockNumber = self.end_number().into();
         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().unpack();
-        let end_epoch: EpochNumberWithFraction = self.end_epoch().unpack();
+        let start_epoch: EpochNumberWithFraction = self.start_epoch().into();
+        let end_epoch: EpochNumberWithFraction = self.end_epoch().into();
         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().unpack();
-        let end_compact_target: u32 = self.end_compact_target().unpack();
-        let total_difficulty: U256 = self.total_difficulty().unpack();
+        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();
         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().unpack();
-            let r: U256 = rhs.total_difficulty().unpack();
+            let l: U256 = lhs.total_difficulty().into();
+            let r: U256 = rhs.total_difficulty().into();
             l + r
         };
 
         // 1. Check block numbers.
-        let lhs_end_number: BlockNumber = lhs.end_number().unpack();
-        let rhs_start_number: BlockNumber = rhs.start_number().unpack();
+        let lhs_end_number: BlockNumber = lhs.end_number().into();
+        let rhs_start_number: BlockNumber = rhs.start_number().into();
         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().unpack();
-        let rhs_start_epoch: EpochNumberWithFraction = rhs.start_epoch().unpack();
+        let lhs_end_epoch: EpochNumberWithFraction = lhs.end_epoch().into();
+        let rhs_start_epoch: EpochNumberWithFraction = rhs.start_epoch().into();
         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.pack())
-            .total_difficulty(total_difficulty.pack())
+            .children_hash(children_hash)
+            .total_difficulty(total_difficulty)
             .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().unpack();
+        let parent_total_difficulty: U256 = self.parent_chain_root.total_difficulty().into();
         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 75c2e152f2..c0fba6a54e 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.pack()
+        ret.into()
     }
 }
 
diff --git a/verification/contextual/src/contextual_block_verifier.rs b/verification/contextual/src/contextual_block_verifier.rs
index cb701abfdf..03ebfd9ad2 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.into())
+            .capacity(block_reward.total)
             .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 a8914bbf7f..b568ab0c2b 100644
--- a/verification/contextual/src/tests/contextual_block_verifier.rs
+++ b/verification/contextual/src/tests/contextual_block_verifier.rs
@@ -14,7 +14,8 @@ use ckb_types::{
         TransactionView, UncleBlockView,
     },
     packed::{
-        self, Byte32, CellDep, CellInput, CellOutputBuilder, OutPoint, ProposalShortId, Script,
+        self, Byte32, CellDep, CellInput, CellOutput, CellOutputBuilder, OutPoint, ProposalShortId,
+        Script,
     },
     prelude::*,
     utilities::DIFF_TWO,
@@ -36,11 +37,15 @@ fn gen_block(
     let cellbase = create_cellbase(number);
     let header = HeaderBuilder::default()
         .parent_hash(parent_header.hash())
-        .timestamp(now.into())
-        .number(number.into())
-        .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
-        .compact_target(compact_target.into())
-        .nonce(nonce.into())
+        .timestamp(now)
+        .number(number)
+        .epoch(EpochNumberWithFraction::new(
+            number / 1000,
+            number % 1000,
+            1000,
+        ))
+        .compact_target(compact_target)
+        .nonce(nonce)
         .build();
 
     BlockBuilder::default()
@@ -59,9 +64,9 @@ fn create_transaction(
 ) -> TransactionView {
     let capacity = 100_000_000 / 100_usize;
     let output = CellOutputBuilder::default()
-        .capacity(Capacity::bytes(capacity).unwrap().into())
+        .capacity(Capacity::bytes(capacity).unwrap())
         .lock(always_success_script.to_owned())
-        .type_(Some(always_success_script.to_owned()).into())
+        .type_(Some(always_success_script.to_owned()))
         .build();
     let inputs: Vec<CellInput> = (0..100)
         .map(|index| CellInput::new(OutPoint::new(parent.clone(), index), 0))
@@ -99,7 +104,7 @@ fn create_cellbase(number: BlockNumber) -> TransactionView {
     TransactionBuilder::default()
         .input(CellInput::new_cellbase_input(number))
         .output(CellOutputBuilder::default().build())
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build()
 }
 
@@ -112,13 +117,13 @@ fn setup_env() -> (ChainController, Shared, Byte32, Script, OutPoint) {
         .output(always_success_cell.clone())
         .outputs(vec![
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(1_000_000).into())
+                .capacity(capacity_bytes!(1_000_000))
                 .lock(always_success_script.clone())
-                .type_(Some(always_success_script.clone()).into())
+                .type_(Some(always_success_script.clone()))
                 .build();
             100
         ])
-        .output_data(always_success_cell_data.to_owned().into())
+        .output_data(always_success_cell_data.to_owned())
         .outputs_data(vec![Bytes::new().into(); 100])
         .build();
     let tx_hash = tx.data().calc_tx_hash();
@@ -145,8 +150,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(Default::default())
-        .output_data(Default::default())
+        .output(CellOutput::default())
+        .output_data(packed::Bytes::default())
         .build();
 
     let cellbase = ResolvedTransaction {
@@ -164,7 +169,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.into()).build();
+    let block = BlockBuilder::default().epoch(actual_epoch).build();
     let mut epoch = EpochExt::default();
     epoch.set_length(1);
 
@@ -184,8 +189,8 @@ fn test_epoch_difficulty() {
     epoch.set_length(1);
 
     let block = BlockBuilder::default()
-        .epoch(epoch.number_with_fraction(0).into())
-        .compact_target(0x200c_30c3u32.into())
+        .epoch(epoch.number_with_fraction(0))
+        .compact_target(0x200c_30c3u32)
         .build();
 
     assert_error_eq!(
diff --git a/verification/contextual/src/tests/uncle_verifier.rs b/verification/contextual/src/tests/uncle_verifier.rs
index 87494b6f43..84dba7b1e7 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::{CellInput, ProposalShortId, Script},
+    packed::{self, CellInput, CellOutput, 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.into())
-        .epoch(epoch.number_with_fraction(number).into())
-        .number(number.into())
-        .compact_target(epoch.compact_target().into())
-        .nonce(nonce.into())
+        .timestamp(now)
+        .epoch(epoch.number_with_fraction(number))
+        .number(number)
+        .compact_target(epoch.compact_target())
+        .nonce(nonce)
         .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(Default::default())
-        .output_data(Default::default())
+        .output(CellOutput::default())
+        .output_data(packed::Bytes::default())
         .build()
 }
 
@@ -169,7 +169,7 @@ fn test_invalid_target() {
     let uncle = chain2[16]
         .clone()
         .as_advanced_builder()
-        .compact_target(invalid_target.into())
+        .compact_target(invalid_target)
         .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().into())
+        .compact_target(chain1[block_number].compact_target())
         .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].into())
+        .proposal([1; 10])
         .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].into())
+        .proposal([1; 10])
         .build()
         .as_uncle();
     let block = chain1[8]
diff --git a/verification/src/tests/block_verifier.rs b/verification/src/tests/block_verifier.rs
index 73bd870ae2..112666849d 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).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -33,12 +33,8 @@ 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.into())
-                .build(),
-        )
-        .output_data(Bytes::new().into())
+        .output(CellOutputBuilder::default().capacity(capacity).build())
+        .output_data(Bytes::new())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -48,10 +44,10 @@ fn create_cellbase_transaction_with_non_empty_output_data() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
-        .output_data(Bytes::from("123").into())
+        .output_data(Bytes::from("123"))
         .witness(Script::default().into_witness())
         .build()
 }
@@ -61,15 +57,15 @@ fn create_cellbase_transaction_with_two_output() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -79,11 +75,11 @@ fn create_cellbase_transaction_with_two_output_data() -> TransactionView {
         .input(CellInput::new_cellbase_input(0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
-        .output_data(Bytes::new().into())
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
+        .output_data(Bytes::new())
         .witness(Script::default().into_witness())
         .build()
 }
@@ -97,10 +93,10 @@ fn create_normal_transaction() -> TransactionView {
         .input(CellInput::new(OutPoint::new(h256!("0x1").into(), 0), 0))
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .build()
 }
 
@@ -195,7 +191,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().into())
+        .output_data(Bytes::new())
         .build();
     let block = BlockBuilder::new_with_number(2)
         .transaction(cellbase_without_output)
@@ -209,7 +205,7 @@ pub fn test_cellbase_without_output() {
         .witness(Script::default().into_witness())
         .output(
             CellOutputBuilder::default()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         )
         .build();
@@ -293,7 +289,7 @@ pub fn test_transaction_root() {
 #[test]
 pub fn test_proposals_root() {
     let header = HeaderBuilder::new_with_number(2)
-        .proposals_hash(h256!("0x1").into())
+        .proposals_hash(h256!("0x1"))
         .build();
     let block = BlockBuilder::default()
         .header(header)
diff --git a/verification/src/tests/genesis_verifier.rs b/verification/src/tests/genesis_verifier.rs
index c31899f1cb..d11bda96e3 100644
--- a/verification/src/tests/genesis_verifier.rs
+++ b/verification/src/tests/genesis_verifier.rs
@@ -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.into())
-        .epoch(EpochNumberWithFraction::from_full_value(0).into())
+        .number(42)
+        .epoch(EpochNumberWithFraction::from_full_value(0))
         .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].into())
+        .parent_hash([42u8; 32])
         .build();
     let consensus = ConsensusBuilder::default()
         .genesis_block(genesis_block)
diff --git a/verification/src/tests/header_verifier.rs b/verification/src/tests/header_verifier.rs
index 716db7fe68..b42269ba34 100644
--- a/verification/src/tests/header_verifier.rs
+++ b/verification/src/tests/header_verifier.rs
@@ -40,7 +40,7 @@ pub fn test_version() {
         .build();
 
     let header = HeaderBuilder::default()
-        .version((consensus.block_version() + 1).into())
+        .version(consensus.block_version() + 1)
         .build();
     let verifier = VersionVerifier::new(&header, &consensus);
 
@@ -53,8 +53,8 @@ pub fn test_version() {
     );
     let epoch = EpochNumberWithFraction::new(10, 40, 1000);
     let header = HeaderBuilder::default()
-        .version((consensus.block_version() + 1).into())
-        .epoch(epoch.into())
+        .version(consensus.block_version() + 1)
+        .epoch(epoch)
         .build();
     let verifier = VersionVerifier::new(&header, &consensus);
     assert!(verifier.verify().is_ok());
@@ -69,7 +69,7 @@ fn test_timestamp() {
     let timestamp = unix_time_as_millis() + 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp.into())
+        .timestamp(timestamp)
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -91,7 +91,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.into())
+        .timestamp(timestamp)
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -119,7 +119,7 @@ fn test_timestamp_too_new() {
     let timestamp = max + 1;
     let header = HeaderBuilder::new_with_number(100)
         .parent_hash(parent_hash)
-        .timestamp(timestamp.into())
+        .timestamp(timestamp)
         .build();
     let timestamp_verifier = TimestampVerifier::new(
         &fake_block_median_time_context,
@@ -161,9 +161,7 @@ fn test_epoch() {
         ];
 
         for epoch_malformed in epochs_malformed {
-            let malformed = HeaderBuilder::default()
-                .epoch(epoch_malformed.into())
-                .build();
+            let malformed = HeaderBuilder::default().epoch(epoch_malformed).build();
             let result = EpochVerifier::new(parent, &malformed).verify();
             assert!(result.is_err(), "input: {epoch_malformed:#}");
             assert_error_eq!(
@@ -207,7 +205,7 @@ fn test_epoch() {
         ];
 
         for (parent, epoch_current) in epochs {
-            let current = HeaderBuilder::default().epoch(epoch_current.into()).build();
+            let current = HeaderBuilder::default().epoch(epoch_current).build();
 
             let result = EpochVerifier::new(parent, &current).verify();
             assert!(result.is_err(), "current: {current:#}, parent: {parent:#}");
@@ -236,7 +234,7 @@ fn test_epoch() {
             ),
         ];
         for (parent, epoch_current) in epochs {
-            let current = HeaderBuilder::default().epoch(epoch_current.into()).build();
+            let current = HeaderBuilder::default().epoch(epoch_current).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 74466a23d2..9fbb34f345 100644
--- a/verification/src/tests/mod.rs
+++ b/verification/src/tests/mod.rs
@@ -14,15 +14,23 @@ trait BuilderBaseOnBlockNumber {
 impl BuilderBaseOnBlockNumber for HeaderBuilder {
     fn new_with_number(number: BlockNumber) -> HeaderBuilder {
         Self::default()
-            .number(number.into())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
+            .number(number)
+            .epoch(EpochNumberWithFraction::new(
+                number / 1000,
+                number % 1000,
+                1000,
+            ))
     }
 }
 
 impl BuilderBaseOnBlockNumber for BlockBuilder {
     fn new_with_number(number: BlockNumber) -> BlockBuilder {
         Self::default()
-            .number(number.into())
-            .epoch(EpochNumberWithFraction::new(number / 1000, number % 1000, 1000).into())
+            .number(number)
+            .epoch(EpochNumberWithFraction::new(
+                number / 1000,
+                number % 1000,
+                1000,
+            ))
     }
 }
diff --git a/verification/src/tests/transaction_verifier.rs b/verification/src/tests/transaction_verifier.rs
index 521d4d0bae..57f2913ca8 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::{Byte32, CellDep, CellInput, CellOutput, OutPoint, Script},
+    packed::{self, 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).into())
+        .version(TX_VERSION + 1)
         .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).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
         )
-        .output_data(data.into())
+        .output_data(data)
         .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).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
         )
-        .output_data(data.into())
+        .output_data(data)
         .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).into())
+                .capacity(capacity_bytes!(50))
                 .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).into())
-                .type_(Some(dao_type_script.clone()).into())
+                .capacity(capacity_bytes!(500))
+                .type_(Some(dao_type_script.clone()))
                 .build(),
         )
-        .output_data(Bytes::new().into())
+        .output_data(Bytes::new())
         .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).into())
+        .capacity(capacity_bytes!(50))
         .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).into())
+        .capacity(capacity_bytes!(50))
         .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).into())
+        .capacity(capacity_bytes!(50))
         .build();
 
     let base_epoch = EpochNumberWithFraction::new(0, 0, 10);
@@ -296,10 +296,10 @@ pub fn test_capacity_invalid() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(100).into())
+                .capacity(capacity_bytes!(100))
                 .build(),
         ])
         .outputs_data(vec![Bytes::new().into(); 2])
@@ -313,14 +313,14 @@ pub fn test_capacity_invalid() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(49).into())
+                    .capacity(capacity_bytes!(49))
                     .build(),
                 Bytes::new(),
             )
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(100).into())
+                    .capacity(capacity_bytes!(100))
                     .build(),
                 Bytes::new(),
             )
@@ -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.into())
-            .epoch(epoch.into())
+            .number(block_number)
+            .epoch(epoch)
             .parent_hash(parent_hash.as_ref().to_owned())
             .build();
         Arc::new(TxVerifyEnv::new_commit(&header))
@@ -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).into())
+                .capacity(capacity_bytes!(50))
                 .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.into())
-            .epoch(epoch.into())
+            .number(block_number)
+            .epoch(epoch)
             .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.into())
-            .epoch(epoch.into())
+            .number(block_number)
+            .epoch(epoch)
             .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.into())
-            .epoch(epoch.into())
+            .number(block_number)
+            .epoch(epoch)
             .parent_hash(parent_hash.as_ref().to_owned())
             .build();
         Arc::new(TxVerifyEnv::new_commit(&header))
@@ -741,7 +741,7 @@ fn test_since_overflow() {
 #[test]
 pub fn test_outputs_data_length_mismatch() {
     let transaction = TransactionBuilder::default()
-        .output(Default::default())
+        .output(CellOutput::default())
         .build();
     let verifier = OutputsDataVerifier::new(&transaction);
 
@@ -754,8 +754,8 @@ pub fn test_outputs_data_length_mismatch() {
     );
 
     let transaction = TransactionBuilder::default()
-        .output(Default::default())
-        .output_data(Default::default())
+        .output(CellOutput::default())
+        .output_data(packed::Bytes::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.into())
+        .hash_type(ScriptHashType::Type)
         .build();
 
     (Arc::new(consensus), dao_type_script)
@@ -825,16 +825,12 @@ fn test_dao_disables_different_lock_script_size() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).into())
-                .lock(
-                    Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).into())
-                        .build(),
-                )
-                .type_(Some(dao_type_script.clone()).into())
+                .capacity(capacity_bytes!(200))
+                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
+                .type_(Some(dao_type_script.clone()))
                 .build(),
         ])
         .outputs_data(vec![Bytes::new().into(); 2])
@@ -846,7 +842,7 @@ fn test_dao_disables_different_lock_script_size() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50).into())
+                    .capacity(capacity_bytes!(50))
                     .build(),
                 Bytes::new(),
             )
@@ -858,9 +854,9 @@ fn test_dao_disables_different_lock_script_size() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201).into())
-                    .lock(Script::new_builder().args(Bytes::new().into()).build())
-                    .type_(Some(dao_type_script).into())
+                    .capacity(capacity_bytes!(201))
+                    .lock(Script::new_builder().args(Bytes::new()).build())
+                    .type_(Some(dao_type_script))
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -888,16 +884,12 @@ fn test_dao_disables_different_lock_script_size_before_limiting_block() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).into())
-                .lock(
-                    Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).into())
-                        .build(),
-                )
-                .type_(Some(dao_type_script.clone()).into())
+                .capacity(capacity_bytes!(200))
+                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
+                .type_(Some(dao_type_script.clone()))
                 .build(),
         ])
         .outputs_data(vec![Bytes::new().into(); 2])
@@ -909,7 +901,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).into())
+                    .capacity(capacity_bytes!(50))
                     .build(),
                 Bytes::new(),
             )
@@ -921,9 +913,9 @@ fn test_dao_disables_different_lock_script_size_before_limiting_block() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201).into())
-                    .lock(Script::new_builder().args(Bytes::new().into()).build())
-                    .type_(Some(dao_type_script).into())
+                    .capacity(capacity_bytes!(201))
+                    .lock(Script::new_builder().args(Bytes::new()).build())
+                    .type_(Some(dao_type_script))
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -948,15 +940,11 @@ fn test_non_dao_allows_lock_script_size() {
     let transaction = TransactionBuilder::default()
         .outputs(vec![
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(50).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).into())
-                .lock(
-                    Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).into())
-                        .build(),
-                )
+                .capacity(capacity_bytes!(200))
+                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
                 .build(),
         ])
         .outputs_data(vec![Bytes::new().into(); 2])
@@ -968,7 +956,7 @@ fn test_non_dao_allows_lock_script_size() {
         resolved_inputs: vec![
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(50).into())
+                    .capacity(capacity_bytes!(50))
                     .build(),
                 Bytes::new(),
             )
@@ -980,8 +968,8 @@ fn test_non_dao_allows_lock_script_size() {
             .build(),
             CellMetaBuilder::from_cell_output(
                 CellOutput::new_builder()
-                    .capacity(capacity_bytes!(201).into())
-                    .lock(Script::new_builder().args(Bytes::new().into()).build())
+                    .capacity(capacity_bytes!(201))
+                    .lock(Script::new_builder().args(Bytes::new()).build())
                     .build(),
                 Bytes::from(vec![0; 8]),
             )
@@ -1006,16 +994,12 @@ 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).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).into())
-                .lock(
-                    Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).into())
-                        .build(),
-                )
-                .type_(Some(dao_type_script.clone()).into())
+                .capacity(capacity_bytes!(200))
+                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
+                .type_(Some(dao_type_script.clone()))
                 .build(),
         ])
         .outputs_data(vec![Bytes::new().into(); 2])
@@ -1027,7 +1011,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).into())
+                    .capacity(capacity_bytes!(50))
                     .build(),
                 Bytes::new(),
             )
@@ -1039,9 +1023,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).into())
-                    .lock(Script::new_builder().args(Bytes::new().into()).build())
-                    .type_(Some(dao_type_script).into())
+                    .capacity(capacity_bytes!(201))
+                    .lock(Script::new_builder().args(Bytes::new()).build())
+                    .type_(Some(dao_type_script))
                     .build(),
                 Bytes::from(vec![1; 8]),
             )
@@ -1066,16 +1050,12 @@ 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).into())
+                .capacity(capacity_bytes!(50))
                 .build(),
             CellOutput::new_builder()
-                .capacity(capacity_bytes!(200).into())
-                .lock(
-                    Script::new_builder()
-                        .args(Bytes::from(vec![1; 20]).into())
-                        .build(),
-                )
-                .type_(Some(dao_type_script).into())
+                .capacity(capacity_bytes!(200))
+                .lock(Script::new_builder().args(Bytes::from(vec![1; 20])).build())
+                .type_(Some(dao_type_script))
                 .build(),
         ])
         .outputs_data(vec![])
@@ -1087,7 +1067,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).into())
+                    .capacity(capacity_bytes!(50))
                     .build(),
                 Bytes::new(),
             )
@@ -1099,8 +1079,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).into())
-                    .lock(Script::new_builder().args(Bytes::new().into()).build())
+                    .capacity(capacity_bytes!(201))
+                    .lock(Script::new_builder().args(Bytes::new()).build())
                     .build(),
                 Bytes::from(vec![1; 8]),
             )