Merge branch 'main' into docs-from-attrs

Author: leighmcculloch

soroban-sdk/src/muxed_address.rs

@@ -353,6 +353,25 @@ impl MuxedAddress {
     }
 }
 
+#[cfg(not(target_family = "wasm"))]
+impl From<&MuxedAddress> for ScVal {
+    fn from(v: &MuxedAddress) -> Self {
+        // This conversion occurs only in test utilities, and theoretically all
+        // values should convert to an ScVal because the Env won't let the host
+        // type to exist otherwise, unwrapping. Even if there are edge cases
+        // that don't, this is a trade off for a better test developer
+        // experience.
+        ScVal::try_from_val(&v.env, &v.to_val()).unwrap()
+    }
+}
+
+#[cfg(not(target_family = "wasm"))]
+impl From<MuxedAddress> for ScVal {
+    fn from(v: MuxedAddress) -> Self {
+        (&v).into()
+    }
+}
+
 #[cfg(not(target_family = "wasm"))]
 impl TryFromVal<Env, ScVal> for MuxedAddress {
     type Error = ConversionError;

soroban-sdk/src/tests/muxed_address.rs

@@ -1,4 +1,4 @@
-use soroban_sdk_macros::{contract, contractimpl};
+use soroban_sdk_macros::{contract, contractimpl, contracttype};
 
 use crate::testutils::{Address as _, MuxedAddress as _};
 use crate::{self as soroban_sdk, Bytes, String};
@@ -7,6 +7,13 @@ use crate::{
     Address, Env, MuxedAddress, TryFromVal,
 };
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[contracttype]
+pub struct Udt {
+    pub address: MuxedAddress,
+    pub amount: i128,
+}
+
 #[contract]
 pub struct MuxedAddressContract;
 
@@ -19,6 +26,10 @@ impl MuxedAddressContract {
     ) -> (Option<u64>, Option<u64>) {
         (a.id(), b.id())
     }
+
+    pub fn echo_udt(_e: Env, udt: Udt) -> Udt {
+        udt
+    }
 }
 
 #[test]
@@ -109,6 +120,32 @@ fn test_accept_muxed_address_argument_in_contract() {
     );
 }
 
+#[test]
+fn test_contracttype_struct_with_address_backed_muxed_address() {
+    let env = Env::default();
+    let contract_id = env.register(MuxedAddressContract, ());
+    let client = MuxedAddressContractClient::new(&env, &contract_id);
+
+    let udt = Udt {
+        address: Address::generate(&env).into(),
+        amount: 42,
+    };
+    assert_eq!(client.echo_udt(&udt), udt.clone());
+}
+
+#[test]
+fn test_contracttype_struct_with_muxed_address() {
+    let env = Env::default();
+    let contract_id = env.register(MuxedAddressContract, ());
+    let client = MuxedAddressContractClient::new(&env, &contract_id);
+
+    let udt = Udt {
+        address: MuxedAddress::generate(&env),
+        amount: 42,
+    };
+    assert_eq!(client.echo_udt(&udt), udt.clone());
+}
+
 #[test]
 fn test_from_str_account() {
     let env = Env::default();

soroban-sdk/src/testutils/arbitrary.rs

@@ -328,7 +328,8 @@ mod objects {
             Fp, Fp2, Fr, G1Affine, G2Affine, FP2_SERIALIZED_SIZE, FP_SERIALIZED_SIZE,
             G1_SERIALIZED_SIZE, G2_SERIALIZED_SIZE,
         },
-        Address, Bytes, BytesN, Duration, Map, String, Symbol, Timepoint, Val, Vec, I256, U256,
+        Address, Bytes, BytesN, Duration, Map, MuxedAddress, String, Symbol, Timepoint, Val, Vec,
+        I256, U256,
     };
 
     use std::string::String as RustString;
@@ -653,6 +654,39 @@ mod objects {
 
     //////////////////////////////////
 
+    #[derive(Arbitrary, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
+    pub enum ArbitraryMuxedAddress {
+        Address(ArbitraryAddress),
+        Muxed { ed25519: [u8; 32], id: u64 },
+    }
+
+    impl SorobanArbitrary for MuxedAddress {
+        type Prototype = ArbitraryMuxedAddress;
+    }
+
+    impl TryFromVal<Env, ArbitraryMuxedAddress> for MuxedAddress {
+        type Error = ConversionError;
+        fn try_from_val(env: &Env, v: &ArbitraryMuxedAddress) -> Result<Self, Self::Error> {
+            use crate::env::xdr::{MuxedEd25519Account, ScAddress, Uint256};
+
+            let sc_addr = match v {
+                ArbitraryMuxedAddress::Address(v) => {
+                    let address = Address::try_from_val(env, v)?;
+                    return Ok(address.into());
+                }
+                ArbitraryMuxedAddress::Muxed { ed25519, id } => {
+                    ScVal::Address(ScAddress::MuxedAccount(MuxedEd25519Account {
+                        ed25519: Uint256(*ed25519),
+                        id: *id,
+                    }))
+                }
+            };
+            Ok(sc_addr.into_val(env))
+        }
+    }
+
+    //////////////////////////////////
+
     #[derive(Arbitrary, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
     pub struct ArbitraryTimepoint {
         inner: u64,

soroban-sdk/test_snapshots/tests/muxed_address/test_contracttype_struct_with_address_backed_muxed_address.1.json

@@ -0,0 +1,61 @@
+{
+  "generators": {
+    "address": 2,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 25,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}

soroban-sdk/test_snapshots/tests/muxed_address/test_contracttype_struct_with_muxed_address.1.json

@@ -0,0 +1,61 @@
+{
+  "generators": {
+    "address": 2,
+    "nonce": 0,
+    "mux_id": 1
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 25,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}