Change clone_with_id function to new constructor.

Author: dmkozh

soroban-sdk/src/muxed_address.rs

@@ -291,20 +291,26 @@ impl crate::testutils::MuxedAddress for MuxedAddress {
         sc_val.try_into_val(env).unwrap()
     }
 
-    fn clone_with_id(&self, new_id: u64) -> crate::MuxedAddress {
-        let mut sc_val = ScVal::try_from_val(&self.env, self.as_val()).unwrap();
-        match &mut sc_val {
+    fn new<T: Into<MuxedAddress>>(address: T, id: u64) -> crate::MuxedAddress {
+        let address: MuxedAddress = address.into();
+        let sc_val = ScVal::try_from_val(&address.env, address.as_val()).unwrap();
+        let account_id = match sc_val {
             ScVal::Address(address) => match address {
-                ScAddress::MuxedAccount(muxed_account) => {
-                    muxed_account.id = new_id;
-                }
-                ScAddress::Account(_)
-                | ScAddress::Contract(_)
-                | ScAddress::ClaimableBalance(_)
-                | ScAddress::LiquidityPool(_) => unreachable!(),
+                ScAddress::MuxedAccount(muxed_account) => muxed_account.ed25519,
+                ScAddress::Account(crate::env::internal::xdr::AccountId(
+                    crate::env::internal::xdr::PublicKey::PublicKeyTypeEd25519(account_id),
+                )) => account_id,
+                ScAddress::Contract(_) => panic!("contract addresses can not be multiplexed"),
+                ScAddress::ClaimableBalance(_) | ScAddress::LiquidityPool(_) => unreachable!(),
             },
             _ => unreachable!(),
-        }
-        sc_val.try_into_val(&self.env).unwrap()
+        };
+        let result_sc_val = ScVal::Address(ScAddress::MuxedAccount(
+            crate::env::internal::xdr::MuxedEd25519Account {
+                id,
+                ed25519: account_id,
+            },
+        ));
+        result_sc_val.try_into_val(&address.env).unwrap()
     }
 }

soroban-sdk/src/tests/muxed_address.rs

@@ -44,7 +44,11 @@ fn test_muxed_address_component_getters() {
     assert_eq!(muxed_address.address(), expected_address);
     assert_eq!(muxed_address.id(), Some(123_456));
 
-    let muxed_address_with_another_id = muxed_address.clone_with_id(u64::MAX);
+    let muxed_address_with_another_id = MuxedAddress::new(muxed_address, u64::MAX);
     assert_eq!(muxed_address_with_another_id.address(), expected_address);
     assert_eq!(muxed_address_with_another_id.id(), Some(u64::MAX));
+
+    let muxed_address_from_address = MuxedAddress::new(muxed_address_with_another_id.address(), 0);
+    assert_eq!(muxed_address_from_address.address(), expected_address);
+    assert_eq!(muxed_address_from_address.id(), Some(0));
 }

soroban-sdk/src/testutils.rs

@@ -446,9 +446,17 @@ pub trait MuxedAddress {
     /// underlying `Address` will be an account (not contract) address.
     fn generate(env: &Env, id: u64) -> crate::MuxedAddress;
 
-    /// Returns a new `MuxedAddress` that has the same `Address` part as this
-    /// `MuxedAdress`, but a new multiplexing identifier (`new_id`).
-    fn clone_with_id(&self, new_id: u64) -> crate::MuxedAddress;
+    /// Returns a new `MuxedAddress` that has the same `Address` part as the
+    /// provided `address` and the provided multiplexing id.
+    ///
+    /// `address` can be either an `Address` or `MuxedAddress` and it has to
+    /// be an account (non-contract) address.
+    ///
+    /// Note on usage: the simplest way to test `MuxedAddress` is to generate
+    /// an arbitrary valid address with `MuxedAddress::generate`, then
+    /// `MuxedAddress::new` can be used to alter only the multiplexing id part
+    /// of that address.
+    fn new<T: Into<crate::MuxedAddress>>(address: T, id: u64) -> crate::MuxedAddress;
 }
 
 pub trait Deployer {