new utils_types mod.

Author: EthanYuan

core/rpc/core/src/impl.rs

@@ -3,6 +3,7 @@ mod build_tx;
 mod operation;
 mod query;
 pub(crate) mod utils;
+pub(crate) mod utils_types;
 
 use core_ckb_client::CkbRpc;
 use core_rpc_types::{

core/rpc/core/src/impl/build_tx.rs

@@ -1,4 +1,4 @@
-use crate::r#impl::{address_to_script, utils};
+use crate::r#impl::{address_to_script, utils, utils_types};
 use crate::{error::CoreError, InnerResult, MercuryRpcImpl};
 
 use common::hash::blake2b_256_to_160;
@@ -773,7 +773,7 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         fixed_fee: u64,
     ) -> InnerResult<(TransactionView, Vec<SignatureAction>, usize)> {
         // init transfer components: build the outputs
-        let mut transfer_components = utils::TransferComponents::new();
+        let mut transfer_components = utils_types::TransferComponents::new();
         for to in &payload.to.to_infos {
             let capacity = to
                 .amount
@@ -954,7 +954,7 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         fixed_fee: u64,
     ) -> InnerResult<(TransactionView, Vec<SignatureAction>, usize)> {
         // init transfer components: build acp inputs and outputs
-        let mut transfer_components = utils::TransferComponents::new();
+        let mut transfer_components = utils_types::TransferComponents::new();
         for to in &payload.to.to_infos {
             let item = Item::Identity(utils::address_to_identity(&to.address)?);
 
@@ -1186,7 +1186,7 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         fixed_fee: u64,
     ) -> InnerResult<(TransactionView, Vec<SignatureAction>, usize)> {
         // init transfer components: build acp inputs and outputs
-        let mut transfer_components = utils::TransferComponents::new();
+        let mut transfer_components = utils_types::TransferComponents::new();
         for to in &payload.to.to_infos {
             let receiver_address =
                 Address::from_str(&to.address).map_err(CoreError::InvalidRpcParams)?;
@@ -1480,7 +1480,7 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         fixed_fee: u64,
     ) -> InnerResult<(TransactionView, Vec<SignatureAction>, usize)> {
         // init transfer components: build acp inputs and outputs
-        let mut transfer_components = utils::TransferComponents::new();
+        let mut transfer_components = utils_types::TransferComponents::new();
         for to in &payload.to.to_infos {
             let item = Item::Identity(utils::address_to_identity(&to.address)?);
 
@@ -1783,7 +1783,7 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         ctx: Context,
         payload: TransferPayload,
         fee: u64,
-        mut transfer_components: utils::TransferComponents,
+        mut transfer_components: utils_types::TransferComponents,
     ) -> InnerResult<(TransactionView, Vec<SignatureAction>, usize)> {
         // balance capacity
         let mut from_items = vec![];

core/rpc/core/src/impl/utils.rs

@@ -1,4 +1,4 @@
-use crate::r#impl::address_to_script;
+use crate::r#impl::{address_to_script, utils_types::*};
 use crate::{error::CoreError, InnerResult, MercuryRpcImpl};
 
 use common::hash::blake2b_160;
@@ -2979,138 +2979,3 @@ pub(crate) fn dedup_json_items(items: Vec<JsonItem>) -> Vec<JsonItem> {
     items.dedup();
     items
 }
-
-#[allow(clippy::upper_case_acronyms)]
-pub enum AssetScriptType {
-    Secp256k1,
-    ACP,
-    ChequeSender(String),
-    ChequeReceiver(String),
-    Dao(Item),
-}
-
-#[derive(Debug, Default)]
-pub struct TransferComponents {
-    pub inputs: Vec<DetailedCell>,
-    pub outputs: Vec<packed::CellOutput>,
-    pub outputs_data: Vec<packed::Bytes>,
-    pub header_deps: Vec<packed::Byte32>,
-    pub script_deps: HashSet<String>,
-    pub signature_actions: HashMap<String, SignatureAction>,
-    pub type_witness_args: HashMap<usize, (packed::BytesOpt, packed::BytesOpt)>,
-    pub fee_change_cell_index: Option<usize>,
-    pub dao_reward_capacity: u64,
-    pub dao_since_map: HashMap<usize, u64>,
-    pub header_dep_map: HashMap<packed::Byte32, usize>,
-}
-
-impl TransferComponents {
-    pub fn new() -> Self {
-        TransferComponents::default()
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum PoolCkbCategory {
-    DaoClaim,
-    CellBase,
-    Acp,
-    NormalSecp,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum PoolUdtCategory {
-    ChequeInTime,
-    ChequeOutTime,
-    SecpUdt,
-    Acp,
-}
-
-pub struct CkbCellsCache {
-    pub items: Vec<Item>,
-    pub item_category_array: Vec<(usize, PoolCkbCategory)>,
-    pub array_index: usize,
-    pub cell_deque: VecDeque<(DetailedCell, AssetScriptType)>,
-}
-
-impl CkbCellsCache {
-    pub fn new(items: Vec<Item>) -> Self {
-        let mut item_category_array = vec![];
-        for (item_index, _) in items.iter().enumerate() {
-            for category_index in &[
-                PoolCkbCategory::DaoClaim,
-                PoolCkbCategory::CellBase,
-                PoolCkbCategory::Acp,
-                PoolCkbCategory::NormalSecp,
-            ] {
-                item_category_array.push((item_index, category_index.to_owned()))
-            }
-        }
-        CkbCellsCache {
-            items,
-            item_category_array,
-            array_index: 0,
-            cell_deque: VecDeque::new(),
-        }
-    }
-}
-
-pub struct UdtCellsCache {
-    pub items: Vec<Item>,
-    pub asset_info: AssetInfo,
-    pub item_category_array: Vec<(usize, PoolUdtCategory)>,
-    pub array_index: usize,
-    pub cell_deque: VecDeque<(DetailedCell, AssetScriptType)>,
-}
-
-impl UdtCellsCache {
-    pub fn new(items: Vec<Item>, asset_info: AssetInfo, source: Source) -> Self {
-        let mut item_category_array = vec![];
-        match source {
-            Source::Claimable => {
-                for (item_index, _) in items.iter().enumerate() {
-                    for category_index in &[PoolUdtCategory::ChequeInTime] {
-                        item_category_array.push((item_index, category_index.to_owned()))
-                    }
-                }
-            }
-            Source::Free => {
-                for (item_index, _) in items.iter().enumerate() {
-                    for category_index in &[
-                        PoolUdtCategory::ChequeOutTime,
-                        PoolUdtCategory::SecpUdt,
-                        PoolUdtCategory::Acp,
-                    ] {
-                        item_category_array.push((item_index, category_index.to_owned()))
-                    }
-                }
-            }
-        }
-
-        UdtCellsCache {
-            items,
-            asset_info,
-            item_category_array,
-            array_index: 0,
-            cell_deque: VecDeque::new(),
-        }
-    }
-}
-
-pub struct AcpCellsCache {
-    pub items: Vec<Item>,
-    pub asset_info: Option<AssetInfo>,
-    pub current_index: usize,
-    pub cell_deque: VecDeque<DetailedCell>,
-}
-
-impl AcpCellsCache {
-    pub fn new(items: Vec<Item>, asset_info: Option<AssetInfo>) -> Self {
-        AcpCellsCache {
-            items,
-            asset_info,
-            current_index: 0,
-            cell_deque: VecDeque::new(),
-        }
-    }
-}

core/rpc/core/src/impl/utils_types.rs

@@ -0,0 +1,141 @@
+use common::DetailedCell;
+use core_rpc_types::{AssetInfo, Item, SignatureAction, Source};
+
+use ckb_types::packed;
+
+use std::collections::{HashMap, HashSet, VecDeque};
+
+#[allow(clippy::upper_case_acronyms)]
+pub enum AssetScriptType {
+    Secp256k1,
+    ACP,
+    ChequeSender(String),
+    ChequeReceiver(String),
+    Dao(Item),
+}
+
+#[derive(Debug, Default)]
+pub struct TransferComponents {
+    pub inputs: Vec<DetailedCell>,
+    pub outputs: Vec<packed::CellOutput>,
+    pub outputs_data: Vec<packed::Bytes>,
+    pub header_deps: Vec<packed::Byte32>,
+    pub script_deps: HashSet<String>,
+    pub signature_actions: HashMap<String, SignatureAction>,
+    pub type_witness_args: HashMap<usize, (packed::BytesOpt, packed::BytesOpt)>,
+    pub fee_change_cell_index: Option<usize>,
+    pub dao_reward_capacity: u64,
+    pub dao_since_map: HashMap<usize, u64>,
+    pub header_dep_map: HashMap<packed::Byte32, usize>,
+}
+
+impl TransferComponents {
+    pub fn new() -> Self {
+        TransferComponents::default()
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum PoolCkbCategory {
+    DaoClaim,
+    CellBase,
+    Acp,
+    NormalSecp,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum PoolUdtCategory {
+    ChequeInTime,
+    ChequeOutTime,
+    SecpUdt,
+    Acp,
+}
+
+pub struct CkbCellsCache {
+    pub items: Vec<Item>,
+    pub item_category_array: Vec<(usize, PoolCkbCategory)>,
+    pub array_index: usize,
+    pub cell_deque: VecDeque<(DetailedCell, AssetScriptType)>,
+}
+
+impl CkbCellsCache {
+    pub fn new(items: Vec<Item>) -> Self {
+        let mut item_category_array = vec![];
+        for (item_index, _) in items.iter().enumerate() {
+            for category_index in &[
+                PoolCkbCategory::DaoClaim,
+                PoolCkbCategory::CellBase,
+                PoolCkbCategory::Acp,
+                PoolCkbCategory::NormalSecp,
+            ] {
+                item_category_array.push((item_index, category_index.to_owned()))
+            }
+        }
+        CkbCellsCache {
+            items,
+            item_category_array,
+            array_index: 0,
+            cell_deque: VecDeque::new(),
+        }
+    }
+}
+
+pub struct UdtCellsCache {
+    pub items: Vec<Item>,
+    pub asset_info: AssetInfo,
+    pub item_category_array: Vec<(usize, PoolUdtCategory)>,
+    pub array_index: usize,
+    pub cell_deque: VecDeque<(DetailedCell, AssetScriptType)>,
+}
+
+impl UdtCellsCache {
+    pub fn new(items: Vec<Item>, asset_info: AssetInfo, source: Source) -> Self {
+        let mut item_category_array = vec![];
+        match source {
+            Source::Claimable => {
+                for (item_index, _) in items.iter().enumerate() {
+                    for category_index in &[PoolUdtCategory::ChequeInTime] {
+                        item_category_array.push((item_index, category_index.to_owned()))
+                    }
+                }
+            }
+            Source::Free => {
+                for (item_index, _) in items.iter().enumerate() {
+                    for category_index in &[
+                        PoolUdtCategory::ChequeOutTime,
+                        PoolUdtCategory::SecpUdt,
+                        PoolUdtCategory::Acp,
+                    ] {
+                        item_category_array.push((item_index, category_index.to_owned()))
+                    }
+                }
+            }
+        }
+
+        UdtCellsCache {
+            items,
+            asset_info,
+            item_category_array,
+            array_index: 0,
+            cell_deque: VecDeque::new(),
+        }
+    }
+}
+
+pub struct AcpCellsCache {
+    pub items: Vec<Item>,
+    pub asset_info: Option<AssetInfo>,
+    pub current_index: usize,
+    pub cell_deque: VecDeque<DetailedCell>,
+}
+
+impl AcpCellsCache {
+    pub fn new(items: Vec<Item>, asset_info: Option<AssetInfo>) -> Self {
+        AcpCellsCache {
+            items,
+            asset_info,
+            current_index: 0,
+            cell_deque: VecDeque::new(),
+        }
+    }
+}