fix: from items must not contain the to item.

Author: EthanYuan

core/rpc/core/src/error.rs

@@ -124,6 +124,9 @@ pub enum CoreError {
 
     #[display(fmt = "Invalid tx prebuilt {}", _0)]
     InvalidTxPrebuilt(String),
+
+    #[display(fmt = "From items must not contain the to item")]
+    FromContainTo,
 }
 
 impl RpcError for CoreError {
@@ -166,6 +169,7 @@ impl RpcError for CoreError {
             CoreError::CannotFindACPCell => -10052,
             CoreError::TransferAmountMustPositive => -10053,
             CoreError::InvalidFeeChange => -10054,
+            CoreError::FromContainTo => -10055,
 
             CoreError::UDTIsNotEnough => -10060,
 

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

@@ -562,7 +562,15 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         utils::check_same_enum_value(payload.from.items.iter().collect())?;
         let mut payload = payload;
         payload.from.items = utils::dedup_json_items(payload.from.items);
-
+        self.check_from_contain_to(
+            payload.from.items.iter().collect(),
+            payload
+                .to
+                .to_infos
+                .iter()
+                .map(|to_info| to_info.address.to_owned())
+                .collect(),
+        )?;
         for to_info in &payload.to.to_infos {
             match u128::from_str(&to_info.amount) {
                 Ok(amount) => {
@@ -1569,13 +1577,35 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         if payload.from.len() > MAX_ITEM_NUM || payload.to.len() > MAX_ITEM_NUM {
             return Err(CoreError::ExceedMaxItemNum.into());
         }
-
         let mut from_items = vec![];
         for address in &payload.from {
             let identity = utils::address_to_identity(address)?;
             from_items.push(JsonItem::Identity(identity.encode()));
         }
         from_items = utils::dedup_json_items(from_items);
+        self.check_from_contain_to(
+            from_items.iter().collect(),
+            payload
+                .to
+                .iter()
+                .map(|to_info| to_info.address.to_owned())
+                .collect(),
+        )?;
+        for to_info in &payload.to {
+            match u128::from_str(&to_info.amount) {
+                Ok(amount) => {
+                    if amount == 0u128 {
+                        return Err(CoreError::TransferAmountMustPositive.into());
+                    }
+                }
+                Err(_) => {
+                    return Err(CoreError::InvalidRpcParams(
+                        "To amount should be a valid u128 number".to_string(),
+                    )
+                    .into());
+                }
+            }
+        }
 
         let mut to_items = vec![];
         for ToInfo { address, .. } in &payload.to {

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

@@ -2827,6 +2827,27 @@ impl<C: CkbRpc> MercuryRpcImpl<C> {
         }
         false
     }
+
+    pub(crate) fn check_from_contain_to(
+        &self,
+        from_items: Vec<&JsonItem>,
+        to_addresses: Vec<String>,
+    ) -> InnerResult<()> {
+        let mut from_secp_lock_args_set = HashSet::new();
+        for json_item in from_items {
+            let item = Item::try_from(json_item.to_owned())?;
+            let args = self.get_secp_lock_args_by_item(item)?;
+            from_secp_lock_args_set.insert(args);
+        }
+        for to_address in to_addresses {
+            let to_item = Item::Identity(address_to_identity(&to_address)?);
+            let to_secp_lock_args = self.get_secp_lock_args_by_item(to_item)?;
+            if from_secp_lock_args_set.contains(&to_secp_lock_args) {
+                return Err(CoreError::FromContainTo.into());
+            }
+        }
+        Ok(())
+    }
 }
 
 pub(crate) fn is_dao_withdraw_unlock(