Merge pull request #8 from oraichain/single-step

Single step

Author: ducphamle2

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

@@ -121,7 +121,11 @@ pub fn reply(deps: DepsMut, _env: Env, reply: Reply) -> Result<Response, Contrac
                     true,
                 )?;
 
-                Ok(Response::new().set_data(ack_fail(err)))
+                Ok(Response::new().set_data(ack_fail(err)).add_attributes(vec![
+                    attr("undo_reduce_channel", reply_args.channel),
+                    attr("undo_reduce_channel_ibc_denom", reply_args.denom),
+                    attr("undo_reduce_channel_amount", reply_args.amount),
+                ]))
             }
         },
         NATIVE_RECEIVE_ID => match reply.result {
@@ -150,7 +154,12 @@ pub fn reply(deps: DepsMut, _env: Env, reply: Reply) -> Result<Response, Contrac
 
                 Ok(Response::new()
                     .set_data(ack_fail(err.clone()))
-                    .add_attribute("error_transferring_ibc_tokens_to_cw20", err))
+                    .add_attribute("error_transferring_ibc_tokens_to_cw20", err)
+                    .add_attributes(vec![
+                        attr("undo_increase_channel", reply_args.channel),
+                        attr("undo_increase_channel_ibc_denom", reply_args.denom),
+                        attr("undo_increase_channel_amount", reply_args.amount),
+                    ]))
             }
         },
         FOLLOW_UP_FAILURE_ID => match reply.result {
@@ -440,17 +449,10 @@ pub fn get_follow_up_msgs(
 ) -> Result<(Vec<CosmosMsg>, String), ContractError> {
     let config = CONFIG.load(storage)?;
     let mut cosmos_msgs: Vec<CosmosMsg> = vec![];
-    if memo.is_empty() {
-        return Ok((
-            vec![send_amount(to_send, receiver.to_string(), None)],
-            "".to_string(),
-        ));
-    }
     let destination: DestinationInfo = DestinationInfo::from_str(memo);
-    // if destination denom, then we simply transfers cw20 to the receiver address.
-    if destination.destination_denom.is_empty() {
+    if is_follow_up_msgs_only_send_amount(&memo, &destination.destination_denom) {
         return Ok((
-            vec![send_amount(to_send, destination.receiver.clone(), None)],
+            vec![send_amount(to_send, receiver.to_string(), None)],
             "".to_string(),
         ));
     }
@@ -476,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,
@@ -508,17 +513,35 @@ 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) -> 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;
+    }
+    false
+}
+
 pub fn build_swap_operations(
     receiver_asset_info: AssetInfo,
     initial_receive_asset_info: AssetInfo,
@@ -529,21 +552,21 @@ pub fn build_swap_operations(
     let fee_denom_asset_info = AssetInfo::NativeToken {
         denom: fee_denom.to_string(),
     };
-    let mut swap_operations = vec![
-        SwapOperation::OraiSwap {
+    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(),
             ask_asset_info: fee_denom_asset_info.clone(),
-        },
-        SwapOperation::OraiSwap {
+        })
+    }
+    if destination_denom.ne(fee_denom) {
+        swap_operations.push(SwapOperation::OraiSwap {
             offer_asset_info: fee_denom_asset_info.clone(),
             ask_asset_info: receiver_asset_info,
-        },
-    ];
-    if destination_denom.eq(fee_denom) {
-        swap_operations.pop();
-    }
-    if initial_receive_asset_info.eq(&fee_denom_asset_info) {
-        swap_operations.pop();
+        });
     }
     swap_operations
 }
@@ -710,8 +733,9 @@ pub fn handle_follow_up_failure(
             false,
         )?;
         response = response.add_attributes(vec![
-            attr("ibc_denom_undo_channel_balance", ibc_data.ibc_denom),
-            attr("remote_amount_undo_channel_balance", ibc_data.remote_amount),
+            attr("undo_reduce_channel", reply_args.channel),
+            attr("undo_reduce_channel_ibc_denom", ibc_data.ibc_denom),
+            attr("undo_reduce_channel_balance", ibc_data.remote_amount),
         ]);
     }
     let refund_amount = Amount::from_parts(

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

@@ -7,8 +7,8 @@ mod test {
 
     use crate::ibc::{
         ack_fail, build_ibc_msg, build_swap_msgs, check_gas_limit, handle_follow_up_failure,
-        ibc_packet_receive, parse_voucher_denom, send_amount, Ics20Ack, Ics20Packet, RECEIVE_ID,
-        REFUND_FAILURE_ID,
+        ibc_packet_receive, is_follow_up_msgs_only_send_amount, parse_voucher_denom, send_amount,
+        Ics20Ack, Ics20Packet, RECEIVE_ID, REFUND_FAILURE_ID,
     };
     use crate::ibc::{build_swap_operations, get_follow_up_msgs};
     use crate::test_helpers::*;
@@ -513,13 +513,13 @@ mod test {
     #[test]
     fn test_swap_operations() {
         let receiver_asset_info = AssetInfo::Token {
-            contract_addr: Addr::unchecked("foobar"),
+            contract_addr: Addr::unchecked("contract"),
         };
         let mut initial_asset_info = AssetInfo::Token {
             contract_addr: Addr::unchecked("addr"),
         };
         let fee_denom = "orai".to_string();
-        let destination: DestinationInfo = DestinationInfo {
+        let mut destination: DestinationInfo = DestinationInfo {
             receiver: "cosmos".to_string(),
             destination_channel: "channel-1".to_string(),
             destination_denom: "foobar".to_string(),
@@ -541,16 +541,54 @@ mod test {
             &destination.destination_denom,
         );
         assert_eq!(operations.len(), 1);
+        assert_eq!(
+            operations[0],
+            SwapOperation::OraiSwap {
+                offer_asset_info: initial_asset_info.clone(),
+                ask_asset_info: AssetInfo::NativeToken {
+                    denom: fee_denom.clone()
+                }
+            }
+        );
         initial_asset_info = AssetInfo::NativeToken {
             denom: "foobar".to_string(),
         };
         let operations = build_swap_operations(
-            receiver_asset_info,
+            receiver_asset_info.clone(),
             initial_asset_info.clone(),
             &fee_denom,
             &destination.destination_denom,
         );
         assert_eq!(operations.len(), 0);
+
+        destination.destination_denom = "atom".to_string();
+        let operations = build_swap_operations(
+            receiver_asset_info.clone(),
+            initial_asset_info.clone(),
+            &fee_denom,
+            &destination.destination_denom,
+        );
+        assert_eq!(operations.len(), 1);
+        assert_eq!(
+            operations[0],
+            SwapOperation::OraiSwap {
+                offer_asset_info: AssetInfo::NativeToken {
+                    denom: fee_denom.clone()
+                },
+                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]
@@ -849,7 +887,41 @@ mod test {
             vec![CosmosMsg::Wasm(WasmMsg::Execute {
                 contract_addr: env.contract.address.to_string(),
                 msg: to_binary(&Cw20ExecuteMsg::Transfer {
-                    recipient: "cosmosabcd".to_string(),
+                    recipient: receiver.to_string(),
+                    amount: amount.clone()
+                })
+                .unwrap(),
+                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(),
@@ -933,4 +1005,14 @@ mod test {
         // should undo reduce channel state
         assert_eq!(channel_state.outstanding, remote_amount)
     }
+
+    #[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("memo", "dest denom"),
+            false
+        );
+    }
 }