feat(interchain-token-service): encode source/recipient addresses as strings instead of XDR

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

@@ -14,7 +14,7 @@ use interchain_token::InterchainTokenClient;
 use soroban_sdk::{
     contract, contractimpl, panic_with_error,
     token::{self, StellarAssetClient},
-    xdr::{FromXdr, ToXdr},
+    xdr::ToXdr,
     Address, Bytes, BytesN, Env, String,
 };
 use soroban_token_sdk::metadata::TokenMetadata;
@@ -532,9 +532,7 @@ impl InterchainTokenService {
                 amount,
                 data,
             }) => {
-                let destination_address = Address::from_xdr(env, &destination_address)
-                    .map_err(|_| ContractError::InvalidDestinationAddress)?;
-
+                let destination_address = Address::from_string_bytes(&destination_address);
                 let token_config_value =
                     Self::token_id_config_with_extended_ttl(env, token_id.clone())?;
 
@@ -597,10 +595,7 @@ impl InterchainTokenService {
                 );
 
                 // Note: attempt to convert a byte string which doesn't represent a valid Soroban address fails at the Host level
-                let minter = minter
-                    .map(|m| Address::from_xdr(env, &m))
-                    .transpose()
-                    .map_err(|_| ContractError::InvalidMinter)?;
+                let minter = minter.map(|m| Address::from_string_bytes(&m));
 
                 let deployed_address = Self::deploy_interchain_token_contract(
                     env,

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

@@ -48,6 +48,7 @@ pub enum HubMessage {
 }
 
 /// The type of token manager used for the tokenId.
+///
 /// Only the variants supported by Stellar ITS are defined here.
 /// The variant values need to match the [ITS spec](https://github.com/axelarnetwork/interchain-token-service/blob/v2.0.0/contracts/interfaces/ITokenManagerType.sol#L9).
 #[contracttype]

contracts/interchain-token-service/tests/executable.rs

@@ -2,6 +2,7 @@ mod utils;
 
 use axelar_gateway::testutils::{generate_proof, get_approve_hash};
 use axelar_gateway::types::Message as GatewayMessage;
+use axelar_soroban_std::testutils::address_to_bytes;
 use axelar_soroban_std::traits::BytesExt;
 use axelar_soroban_std::{assert_invoke_auth_err, events};
 use interchain_token_service::types::{HubMessage, InterchainTransfer, Message};
@@ -131,13 +132,14 @@ fn interchain_transfer_execute_succeeds() {
     let deployer = Address::generate(&env);
     let token_id = setup_its_token(&env, &client, &deployer, amount);
     let data = Bytes::from_hex(&env, "dead");
+    let destination_address = address_to_bytes(&env, &executable_id);
 
     let msg = HubMessage::ReceiveFromHub {
         source_chain: String::from_str(&env, HUB_CHAIN),
         message: Message::InterchainTransfer(InterchainTransfer {
             token_id: token_id.clone(),
             source_address: sender,
-            destination_address: executable_id.clone().to_xdr(&env),
+            destination_address,
             amount,
             data: Some(data.clone()),
         }),
@@ -181,7 +183,7 @@ fn executable_fails_if_not_executed_from_its() {
     let executable_client = test::ExecutableContractClient::new(&env, &executable_id);
 
     let source_chain = client.its_hub_chain_name();
-    let source_address = Address::generate(&env).to_xdr(&env);
+    let source_address = address_to_bytes(&env, &Address::generate(&env));
     let amount = 1000;
     let token_id = BytesN::<32>::from_array(&env, &[1; 32]);
     let token_address = Address::generate(&env);

contracts/interchain-token-service/tests/execute.rs

@@ -2,6 +2,7 @@ mod utils;
 
 use axelar_gateway::types::Message as GatewayMessage;
 use axelar_soroban_std::events;
+use axelar_soroban_std::testutils::address_to_bytes;
 use interchain_token_service::event::{
     InterchainTokenDeployedEvent, InterchainTransferReceivedEvent,
 };
@@ -67,7 +68,7 @@ fn interchain_transfer_message_execute_succeeds() {
     register_chains(&env, &client);
 
     let sender = Address::generate(&env).to_xdr(&env);
-    let recipient = Address::generate(&env).to_xdr(&env);
+    let recipient = address_to_bytes(&env, &Address::generate(&env));
     let source_chain = client.its_hub_chain_name();
     let source_address = Address::generate(&env).to_string();
 
@@ -116,7 +117,7 @@ fn deploy_interchain_token_message_execute_succeeds() {
     register_chains(&env, &client);
 
     let sender = Address::generate(&env);
-    let sender_bytes = sender.clone().to_xdr(&env);
+    let sender_bytes = address_to_bytes(&env, &sender);
     let source_chain = client.its_hub_chain_name();
     let source_address = Address::generate(&env).to_string();
 
@@ -319,7 +320,7 @@ fn deploy_interchain_token_message_execute_fails_token_already_deployed() {
     let (env, client, gateway_client, _, signers) = setup_env();
     register_chains(&env, &client);
 
-    let sender = Address::generate(&env).to_xdr(&env);
+    let sender = address_to_bytes(&env, &Address::generate(&env));
     let source_chain = client.its_hub_chain_name();
     let source_address = Address::generate(&env).to_string();
 

contracts/interchain-token-service/tests/flow_limit.rs

@@ -1,6 +1,7 @@
 mod utils;
 
 use axelar_gateway::types::Message as GatewayMessage;
+use axelar_soroban_std::testutils::address_to_bytes;
 use axelar_soroban_std::{assert_contract_err, assert_invoke_auth_ok, events, traits::BytesExt};
 use interchain_token_service::{
     error::ContractError,
@@ -9,7 +10,7 @@ use interchain_token_service::{
     InterchainTokenServiceClient,
 };
 use soroban_sdk::testutils::{Address as _, Ledger as _};
-use soroban_sdk::{vec, xdr::ToXdr, Address, Bytes, BytesN, Env, String, Vec};
+use soroban_sdk::{vec, Address, Bytes, BytesN, Env, String, Vec};
 use utils::{
     approve_gateway_messages, register_chains, setup_env, setup_gas_token, setup_its_token,
     HUB_CHAIN,
@@ -36,8 +37,8 @@ fn create_interchain_transfer_message(
     token_id: &BytesN<32>,
     amount: i128,
 ) -> (String, String, String, Bytes, Vec<GatewayMessage>) {
-    let sender = Address::generate(env).to_xdr(env);
-    let recipient = Address::generate(env).to_xdr(env);
+    let sender = address_to_bytes(env, &Address::generate(env));
+    let recipient = address_to_bytes(env, &Address::generate(env));
     let source_chain = client.its_hub_chain_name();
     let source_address = Address::generate(env).to_string();
 

contracts/interchain-token-service/tests/message_routing.rs

@@ -1,7 +1,8 @@
 mod utils;
+use axelar_soroban_std::testutils::address_to_bytes;
 use axelar_soroban_std::{assert_contract_err, traits::BytesExt};
 use interchain_token_service::error::ContractError;
-use soroban_sdk::{testutils::Address as _, xdr::ToXdr, Address, Bytes, String};
+use soroban_sdk::{testutils::Address as _, Address, Bytes, String};
 use utils::{register_chains, setup_env, setup_gas_token, setup_its_token};
 
 #[test]
@@ -42,7 +43,7 @@ fn send_to_untrusted_chain_fails() {
             &sender,
             &token_id,
             &String::from_str(&env, "untrusted_chain"),
-            &Address::generate(&env).to_xdr(&env),
+            &address_to_bytes(&env, &Address::generate(&env)),
             &amount,
             &None,
             &gas_token,

packages/axelar-soroban-std/src/testutils.rs

@@ -3,7 +3,7 @@ extern crate std;
 
 use soroban_sdk::{
     testutils::{AuthorizedFunction, AuthorizedInvocation, Events},
-    vec, Address, Env, IntoVal, Symbol, Val, Vec,
+    vec, Address, Bytes, Env, IntoVal, Symbol, Val, Vec,
 };
 
 /// Asserts invocation auth of a contract from a single caller.
@@ -33,6 +33,7 @@ pub fn assert_invocation<T>(
 }
 
 /// Asserts that the event at `event_index` in the environment's emitted events is the expected event.
+///
 /// If `event_index` is negative, the length of events will be added to it, i.e it'll be indexed from the end.
 pub fn assert_emitted_event<U, V>(
     env: &Env,
@@ -71,6 +72,15 @@ where
     assert_emitted_event(env, -1, contract_id, topics, data);
 }
 
+// Converts Stellar address (soroban_sdk::Address) to soroban_sdk::Bytes
+pub fn address_to_bytes(env: &Env, address: &Address) -> Bytes {
+    let address_str = address.to_string();
+    let mut str_bytes = [0u8; 56];
+    address_str.copy_into_slice(&mut str_bytes);
+    let address_bytes: Bytes = Bytes::from_slice(env, &str_bytes);
+    address_bytes
+}
+
 /// Helper macro for building and verifying authorization chains in Soroban contract tests.
 ///
 /// Used to verify that contract calls require the correct sequence of authorizations.