feat(interchain-token-service): add message routing (#90)

Co-authored-by: Milap Sheth <milap@interoplabs.io>

Author: AttissNgo

contracts/interchain-token-service/Cargo.toml

@@ -26,8 +26,5 @@ goldie = { workspace = true }
 hex = "0.4"
 soroban-sdk = { workspace = true, features = ["testutils", "alloc"] }
 
-[features]
-testutils = ["soroban-sdk/testutils", "axelar-soroban-std/testutils"]
-
 [lints]
 workspace = true

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

@@ -1,24 +1,16 @@
 use alloy_primitives::{FixedBytes, Uint, U256};
 use alloy_sol_types::{sol, SolValue};
 use axelar_soroban_std::ensure;
-use soroban_sdk::{contracterror, Bytes, BytesN, Env, String};
+use soroban_sdk::{Bytes, BytesN, Env, String};
 
+// alloc needed for converting to alloy types
+use crate::abi::alloc::{string::String as StdString, vec};
+use crate::error::ContractError;
 use crate::types::{self, HubMessage, Message};
 extern crate alloc;
-use crate::abi::alloc::{string::String as StdString, vec};
-
-#[contracterror]
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[repr(u32)]
-pub enum MessageError {
-    InsufficientMessageLength = 0,
-    InvalidMessageType = 1,
-    AbiDecodeFailed = 2,
-    InvalidAmount = 3,
-    InvalidUtf8 = 4,
-}
 
 sol! {
+    #[derive(PartialEq, Eq)]
     enum MessageType {
         InterchainTransfer,
         DeployInterchainToken,
@@ -59,7 +51,7 @@ sol! {
 }
 
 impl Message {
-    pub fn abi_encode(self, env: &Env) -> Result<Bytes, MessageError> {
+    pub fn abi_encode(self, env: &Env) -> Result<Bytes, ContractError> {
         let msg = match self {
             Self::InterchainTransfer(types::InterchainTransfer {
                 token_id,
@@ -95,18 +87,15 @@ impl Message {
         Ok(Bytes::from_slice(env, &msg))
     }
 
-    pub fn abi_decode(env: &Env, payload: &Bytes) -> Result<Self, MessageError> {
-        ensure!(payload.len() >= 32, MessageError::InsufficientMessageLength);
-
+    pub fn abi_decode(env: &Env, payload: &Bytes) -> Result<Self, ContractError> {
         let payload = payload.to_alloc_vec();
 
-        let message_type = MessageType::abi_decode(&payload[0..32], true)
-            .map_err(|_| MessageError::InvalidMessageType)?;
+        let message_type = get_message_type(&payload)?;
 
         match message_type {
             MessageType::InterchainTransfer => {
                 let decoded = InterchainTransfer::abi_decode_params(&payload, true)
-                    .map_err(|_| MessageError::AbiDecodeFailed)?;
+                    .map_err(|_| ContractError::AbiDecodeFailed)?;
 
                 Ok(Self::InterchainTransfer(types::InterchainTransfer {
                     token_id: BytesN::from_array(env, &decoded.tokenId.into()),
@@ -121,7 +110,7 @@ impl Message {
             }
             MessageType::DeployInterchainToken => {
                 let decoded = DeployInterchainToken::abi_decode_params(&payload, true)
-                    .map_err(|_| MessageError::AbiDecodeFailed)?;
+                    .map_err(|_| ContractError::AbiDecodeFailed)?;
 
                 Ok(Self::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(env, &decoded.tokenId.into()),
@@ -131,14 +120,13 @@ impl Message {
                     minter: from_vec(env, decoded.minter.as_ref()),
                 }))
             }
-            _ => Err(MessageError::InvalidMessageType),
+            _ => Err(ContractError::InvalidMessageType),
         }
     }
 }
 
-#[allow(dead_code)]
 impl HubMessage {
-    pub fn abi_encode(self, env: &Env) -> Result<Bytes, MessageError> {
+    pub fn abi_encode(self, env: &Env) -> Result<Bytes, ContractError> {
         let msg = match self {
             Self::SendToHub {
                 destination_chain,
@@ -162,18 +150,15 @@ impl HubMessage {
         Ok(Bytes::from_slice(env, &msg))
     }
 
-    pub fn abi_decode(env: &Env, payload: &Bytes) -> Result<Self, MessageError> {
-        ensure!(payload.len() >= 32, MessageError::InsufficientMessageLength);
-
+    pub fn abi_decode(env: &Env, payload: &Bytes) -> Result<Self, ContractError> {
         let payload = payload.to_alloc_vec();
 
-        let message_type = MessageType::abi_decode(&payload[0..32], true)
-            .map_err(|_| MessageError::InvalidMessageType)?;
+        let message_type = get_message_type(&payload)?;
 
         match message_type {
             MessageType::SendToHub => {
                 let decoded = SendToHub::abi_decode_params(&payload, true)
-                    .map_err(|_| MessageError::AbiDecodeFailed)?;
+                    .map_err(|_| ContractError::AbiDecodeFailed)?;
 
                 Ok(Self::SendToHub {
                     destination_chain: String::from_str(env, &decoded.destination_chain),
@@ -185,7 +170,7 @@ impl HubMessage {
             }
             MessageType::ReceiveFromHub => {
                 let decoded = ReceiveFromHub::abi_decode_params(&payload, true)
-                    .map_err(|_| MessageError::AbiDecodeFailed)?;
+                    .map_err(|_| ContractError::AbiDecodeFailed)?;
 
                 Ok(Self::ReceiveFromHub {
                     source_chain: String::from_str(env, &decoded.source_chain),
@@ -195,19 +180,31 @@ impl HubMessage {
                     )?,
                 })
             }
-            _ => Err(MessageError::InvalidMessageType),
+            _ => Err(ContractError::InvalidMessageType),
         }
     }
 }
 
-fn to_std_string(soroban_string: String) -> Result<StdString, MessageError> {
+pub fn get_message_type(payload: &[u8]) -> Result<MessageType, ContractError> {
+    ensure!(
+        payload.len() >= 32,
+        ContractError::InsufficientMessageLength
+    );
+
+    let message_type = MessageType::abi_decode(&payload[0..32], true)
+        .map_err(|_| ContractError::InvalidMessageType)?;
+
+    Ok(message_type)
+}
+
+fn to_std_string(soroban_string: String) -> Result<StdString, ContractError> {
     let length = soroban_string.len() as usize;
     let mut bytes = vec![0u8; length];
     soroban_string.copy_into_slice(&mut bytes);
-    StdString::from_utf8(bytes).map_err(|_| MessageError::InvalidUtf8)
+    StdString::from_utf8(bytes).map_err(|_| ContractError::InvalidUtf8)
 }
 
-fn to_i128(value: Uint<256, 4>) -> Result<i128, MessageError> {
+fn to_i128(value: Uint<256, 4>) -> Result<i128, ContractError> {
     let slice = value.as_le_slice();
 
     let mut bytes_to_remove = [0; 16];
@@ -217,12 +214,12 @@ fn to_i128(value: Uint<256, 4>) -> Result<i128, MessageError> {
 
     ensure!(
         i128::from_le_bytes(bytes_to_remove) == 0,
-        MessageError::InvalidAmount
+        ContractError::InvalidAmount
     );
 
     let i128_value = i128::from_le_bytes(bytes_to_convert);
 
-    ensure!(i128_value >= 0, MessageError::InvalidAmount);
+    ensure!(i128_value >= 0, ContractError::InvalidAmount);
 
     Ok(i128_value)
 }
@@ -253,7 +250,7 @@ mod tests {
     use soroban_sdk::{Bytes, BytesN, Env, String};
     use std::vec::Vec;
 
-    fn bytes_from_hex(env: &Env, hex_string: &str) -> Bytes {
+    pub fn bytes_from_hex(env: &Env, hex_string: &str) -> Bytes {
         let bytes_vec: Vec<u8> = hex::decode(hex_string).unwrap();
         Bytes::from_slice(env, &bytes_vec)
     }
@@ -305,7 +302,7 @@ mod tests {
 
         for sequence in invalid_sequences {
             let result = to_std_string(sequence);
-            assert!(matches!(result, Err(MessageError::InvalidUtf8)));
+            assert!(matches!(result, Err(ContractError::InvalidUtf8)));
         }
     }
 
@@ -340,18 +337,18 @@ mod tests {
 
         let result = to_i128(bad_uint);
 
-        assert!(matches!(result, Err(MessageError::InvalidAmount)));
+        assert!(matches!(result, Err(ContractError::InvalidAmount)));
     }
 
     #[test]
     fn to_i128_fails_overflow() {
         let overflow: Uint<256, 4> = Uint::from(i128::MAX) + Uint::from(1);
         let result = to_i128(overflow);
-        assert!(matches!(result, Err(MessageError::InvalidAmount)));
+        assert!(matches!(result, Err(ContractError::InvalidAmount)));
 
         let overflow: Uint<256, 4> = Uint::from(u128::MAX);
         let result = to_i128(overflow);
-        assert!(matches!(result, Err(MessageError::InvalidAmount)));
+        assert!(matches!(result, Err(ContractError::InvalidAmount)));
     }
 
     #[test]
@@ -529,7 +526,7 @@ mod tests {
         let invalid_payload = Bytes::from_slice(&env, &bytes);
 
         let result = HubMessage::abi_decode(&env, &invalid_payload);
-        assert!(matches!(result, Err(MessageError::InvalidMessageType)));
+        assert!(matches!(result, Err(ContractError::InvalidMessageType)));
 
         let invalid_hub_message_type = assert_ok!(types::Message::InterchainTransfer(
             types::InterchainTransfer {
@@ -543,6 +540,6 @@ mod tests {
         .abi_encode(&env));
 
         let result = HubMessage::abi_decode(&env, &invalid_hub_message_type);
-        assert!(matches!(result, Err(MessageError::InvalidMessageType)));
+        assert!(matches!(result, Err(ContractError::InvalidMessageType)));
     }
 }