updated logic no swap when init receiver asset equal dest asset

Author: ducphamle2

contracts/cw-ics20-latest/artifacts/cw-ics20-latest.wasm

@@ -450,12 +450,7 @@ pub fn get_follow_up_msgs(
     let config = CONFIG.load(storage)?;
     let mut cosmos_msgs: Vec<CosmosMsg> = vec![];
     let destination: DestinationInfo = DestinationInfo::from_str(memo);
-    if is_follow_up_msgs_only_send_amount(
-        &memo,
-        &destination.destination_denom,
-        &initial_receive_asset_info.to_string(),
-        &config.fee_denom,
-    ) {
+    if is_follow_up_msgs_only_send_amount(&memo, &destination.destination_denom) {
         return Ok((
             vec![send_amount(to_send, receiver.to_string(), None)],
             "".to_string(),
@@ -483,22 +478,25 @@ pub fn get_follow_up_msgs(
         config.fee_denom.as_str(),
         &destination.destination_denom,
     );
-
-    let response: SimulateSwapOperationsResponse = querier.query_wasm_smart(
-        config.swap_router_contract.clone(),
-        &oraiswap::router::QueryMsg::SimulateSwapOperations {
-            offer_amount: to_send.amount().clone(),
-            operations: swap_operations.clone(),
-        },
-    )?;
+    let mut minimum_receive = to_send.amount();
+    if swap_operations.len() > 0 {
+        let response: SimulateSwapOperationsResponse = querier.query_wasm_smart(
+            config.swap_router_contract.clone(),
+            &oraiswap::router::QueryMsg::SimulateSwapOperations {
+                offer_amount: to_send.amount().clone(),
+                operations: swap_operations.clone(),
+            },
+        )?;
+        minimum_receive = response.amount;
+    }
 
     let ibc_msg = build_ibc_msg(
         storage,
         env,
         receiver_asset_info,
         receiver,
         packet.dest.channel_id.as_str(),
-        response.amount.clone(),
+        minimum_receive.clone(),
         &sender,
         &destination,
         config.default_timeout,
@@ -515,40 +513,32 @@ pub fn get_follow_up_msgs(
         ibc_error_msg = ibc_msg.unwrap_err().to_string();
     }
     build_swap_msgs(
-        response.amount,
+        minimum_receive,
         &config.swap_router_contract,
         to_send.amount(),
         initial_receive_asset_info,
         to,
         &mut cosmos_msgs,
         swap_operations,
     )?;
+    // fallback case. If there's no cosmos messages then we return send amount
+    if cosmos_msgs.is_empty() {
+        return Ok((
+            vec![send_amount(to_send, receiver.to_string(), None)],
+            ibc_error_msg,
+        ));
+    }
     return Ok((cosmos_msgs, ibc_error_msg));
 }
 
-pub fn is_follow_up_msgs_only_send_amount(
-    memo: &str,
-    destination_denom: &str,
-    initial_receive_asset_info: &str,
-    fee_denom: &str,
-) -> bool {
+pub fn is_follow_up_msgs_only_send_amount(memo: &str, destination_denom: &str) -> bool {
     if memo.is_empty() {
         return true;
     }
     // if destination denom, then we simply transfers cw20 to the receiver address.
     if destination_denom.is_empty() {
         return true;
     }
-    // special case, if inital receiver asset info is native orai (fee denom in this case), and the destination is also orai => we just transfer instead of swapping
-    // the reason is that orai is the central asset info for swapping. There's no ORAI/ORAI pair
-    if initial_receive_asset_info.eq(&AssetInfo::NativeToken {
-        denom: fee_denom.to_string(),
-    }
-    .to_string())
-        && destination_denom.eq(fee_denom)
-    {
-        return true;
-    }
     false
 }
 
@@ -563,6 +553,9 @@ pub fn build_swap_operations(
         denom: fee_denom.to_string(),
     };
     let mut swap_operations = vec![];
+    if receiver_asset_info.eq(&initial_receive_asset_info) {
+        return vec![];
+    }
     if initial_receive_asset_info.ne(&fee_denom_asset_info) {
         swap_operations.push(SwapOperation::OraiSwap {
             offer_asset_info: initial_receive_asset_info.clone(),

contracts/cw-ics20-latest/src/ibc.rs

@@ -575,9 +575,20 @@ mod test {
                 offer_asset_info: AssetInfo::NativeToken {
                     denom: fee_denom.clone()
                 },
-                ask_asset_info: receiver_asset_info
+                ask_asset_info: receiver_asset_info.clone()
             }
         );
+
+        // initial = receiver => build swap ops length = 0
+        let operations = build_swap_operations(
+            AssetInfo::NativeToken {
+                denom: "foobar".to_string(),
+            },
+            initial_asset_info.clone(),
+            "not_foo_bar",
+            &destination.destination_denom,
+        );
+        assert_eq!(operations.len(), 0);
     }
 
     #[test]
@@ -883,6 +894,40 @@ mod test {
                 funds: vec![]
             })]
         );
+
+        // 3rd case, cosmos msgs empty case, also send amount
+        let memo = "cosmosabcd:orai";
+        let result = get_follow_up_msgs(
+            deps_mut.storage,
+            deps_mut.api,
+            &deps_mut.querier,
+            env.clone(),
+            Amount::Cw20(Cw20Coin {
+                address: "foobar".to_string(),
+                amount,
+            }),
+            AssetInfo::NativeToken {
+                denom: "orai".to_string(),
+            },
+            "foobar",
+            "foobar",
+            memo,
+            &mock_receive_packet_remote_to_local("channel", 1u128, "foobar", "foobar"),
+        )
+        .unwrap();
+
+        assert_eq!(
+            result.0,
+            vec![CosmosMsg::Wasm(WasmMsg::Execute {
+                contract_addr: env.contract.address.to_string(),
+                msg: to_binary(&Cw20ExecuteMsg::Transfer {
+                    recipient: receiver.to_string(),
+                    amount: amount.clone()
+                })
+                .unwrap(),
+                funds: vec![]
+            })]
+        );
     }
 
     #[test]
@@ -963,52 +1008,11 @@ mod test {
 
     #[test]
     fn test_is_follow_up_msgs_only_send_amount() {
+        assert_eq!(is_follow_up_msgs_only_send_amount("", "dest denom"), true);
+        assert_eq!(is_follow_up_msgs_only_send_amount("memo", ""), true);
         assert_eq!(
-            is_follow_up_msgs_only_send_amount("", "dest denom", "initial info", "fee denom"),
-            true
-        );
-        assert_eq!(
-            is_follow_up_msgs_only_send_amount("memo", "", "initial info", "fee denom"),
-            true
-        );
-        // dest denom no equal to fee denom, return false
-        assert_eq!(
-            is_follow_up_msgs_only_send_amount(
-                "memo",
-                "dest denom",
-                &AssetInfo::NativeToken {
-                    denom: "fee_denom".to_string()
-                }
-                .to_string(),
-                "fee_denom"
-            ),
+            is_follow_up_msgs_only_send_amount("memo", "dest denom"),
             false
         );
-        // initial no equal to fee denom => return false
-        assert_eq!(
-            is_follow_up_msgs_only_send_amount(
-                "memo",
-                "fee_denom",
-                &AssetInfo::NativeToken {
-                    denom: "foobar".to_string()
-                }
-                .to_string(),
-                "fee_denom"
-            ),
-            false
-        );
-        // both dest denom and initial equal fee denom => true
-        assert_eq!(
-            is_follow_up_msgs_only_send_amount(
-                "memo",
-                "fee_denom",
-                &AssetInfo::NativeToken {
-                    denom: "fee_denom".to_string()
-                }
-                .to_string(),
-                "fee_denom"
-            ),
-            true
-        );
     }
 }