feat(interchain-token-service): apply scaling factor on token transfe…

…r based on token decimals

contracts/interchain-token-service/src/contract/execute.rs

@@ -1,5 +1,5 @@
 use axelar_wasm_std::{killswitch, nonempty, FnExt, IntoContractError};
-use cosmwasm_std::{DepsMut, HexBinary, QuerierWrapper, Response, Storage};
+use cosmwasm_std::{DepsMut, HexBinary, QuerierWrapper, Response, Storage, Uint256};
 use error_stack::{bail, ensure, report, Result, ResultExt};
 use router_api::{Address, ChainName, ChainNameRaw, CrossChainId};
 
@@ -34,6 +34,14 @@ pub enum Error {
     SaveChainConfig(ChainNameRaw),
     #[error("chain {0} is frozen")]
     ChainFrozen(ChainNameRaw),
+    #[error(
+        "invalid transfer amount {amount} from chain {source_chain} to chain {destination_chain}"
+    )]
+    InvalidTransferAmount {
+        source_chain: ChainNameRaw,
+        destination_chain: ChainNameRaw,
+        amount: nonempty::Uint256,
+    },
     #[error("state error")]
     State,
 }
@@ -197,6 +205,78 @@ pub fn set_chain_config(
     }
 }
 
+#[allow(unused)]
+fn translate_amount_on_token_transfer(
+    storage: &dyn Storage,
+    src_chain: &ChainNameRaw,
+    dest_chain: &ChainNameRaw,
+    message: Message,
+) -> Result<Message, Error> {
+    match message {
+        Message::InterchainTransfer {
+            token_id,
+            source_address,
+            destination_address,
+            amount,
+            data,
+        } => {
+            let src_chain_decimals = state::load_token_decimals(storage, src_chain, token_id)
+                .change_context(Error::State)?;
+            let dest_chain_decimals = state::load_token_decimals(storage, dest_chain, token_id)
+                .change_context(Error::State)?;
+
+            let dest_chain_amount = if src_chain_decimals > dest_chain_decimals {
+                amount
+                    .checked_div(
+                        Uint256::from_u128(10)
+                            .checked_pow((src_chain_decimals - dest_chain_decimals).into())
+                            .change_context_lazy(|| Error::InvalidTransferAmount {
+                                source_chain: src_chain.to_owned(),
+                                destination_chain: dest_chain.to_owned(),
+                                amount,
+                            })?,
+                    )
+                    .change_context_lazy(|| Error::InvalidTransferAmount {
+                        source_chain: src_chain.to_owned(),
+                        destination_chain: dest_chain.to_owned(),
+                        amount,
+                    })?
+            } else {
+                amount
+                    .checked_mul(
+                        Uint256::from_u128(10)
+                            .checked_pow((dest_chain_decimals - src_chain_decimals).into())
+                            .change_context_lazy(|| Error::InvalidTransferAmount {
+                                source_chain: src_chain.to_owned(),
+                                destination_chain: dest_chain.to_owned(),
+                                amount,
+                            })?,
+                    )
+                    .change_context_lazy(|| Error::InvalidTransferAmount {
+                        source_chain: src_chain.to_owned(),
+                        destination_chain: dest_chain.to_owned(),
+                        amount,
+                    })?
+            };
+
+            Ok(Message::InterchainTransfer {
+                token_id,
+                source_address,
+                destination_address,
+                amount: nonempty::Uint256::try_from(dest_chain_amount).change_context_lazy(
+                    || Error::InvalidTransferAmount {
+                        source_chain: src_chain.to_owned(),
+                        destination_chain: dest_chain.to_owned(),
+                        amount,
+                    },
+                )?,
+                data,
+            })
+        }
+        _ => Ok(message),
+    }
+}
+
 #[allow(unused)]
 fn translate_and_save_token_decimals_on_token_deployment(
     storage: &mut dyn Storage,

contracts/interchain-token-service/src/state.rs

@@ -99,6 +99,14 @@ pub fn save_token_decimals(
     todo!()
 }
 
+pub fn load_token_decimals(
+    _storage: &dyn Storage,
+    _chain: &ChainNameRaw,
+    _token_id: TokenId,
+) -> Result<u8, Error> {
+    todo!()
+}
+
 pub fn may_load_its_contract(
     storage: &dyn Storage,
     chain: &ChainNameRaw,

packages/axelar-wasm-std/src/nonempty/uint.rs

@@ -56,6 +56,12 @@ impl fmt::Display for Uint64 {
 #[serde(try_from = "cosmwasm_std::Uint256")]
 pub struct Uint256(cosmwasm_std::Uint256);
 
+impl fmt::Display for Uint256 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl TryFrom<cosmwasm_std::Uint256> for Uint256 {
     type Error = Error;