Simplify contract event testing (#1638)

### What

Adds a testutils struct `ContractEvents` to be returned by
`env.events().all()` that now returns the XDR variants of the emitted
contract events. To simplify testing, Events defined by `contractevents`
can be converted to the XDR variant with `to_contract_event`.

Additional partial eq impl were added to maintain backwards
compatibility with users who test with existing methods. This will
impact tests where users directly check the length of the events array,
via `all().len()`, who will now need to write `all().events.len()`.

Lastly, this also allows the debug information when testing events to
display actual values, making it easier to determine what went wrong
during test failures:

Before:
```
left: Vec(Ok((Contract(CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM), Vec(Ok(Symbol(transfer)), Ok(Address(obj#35)), Ok(Address(obj#37))), Map(obj#43))))
right: Vec(Ok((Contract(CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM), Vec(Ok(Symbol(transfer)), Ok(Address(obj#11)), Ok(Address(obj#29))), Map(obj#53))))
```

After:
```
left: [ContractEvent { ext: V0, contract_id: Some(ContractId(Hash(0000000000000000000000000000000000000000000000000000000000000001))), type_: Contract, body: V0(ContractEventV0 { topics: VecM([Symbol(ScSymbol(StringM(transfer))), Address(Contract(ContractId(Hash(0000000000000000000000000000000000000000000000000000000000000002)))), Address(Account(AccountId(PublicKeyTypeEd25519(Uint256(0000000000000000000000000000000000000000000000000000000000000003)))))]), data: Map(Some(ScMap(VecM([ScMapEntry { key: Symbol(ScSymbol(StringM(amount))), val: I128(Int128Parts { hi: 0, lo: 1 }) }, ScMapEntry { key: Symbol(ScSymbol(StringM(to_muxed_id))), val: U64(1) }])))) }) }]
right: [ContractEvent { ext: V0, contract_id: Some(ContractId(Hash(0000000000000000000000000000000000000000000000000000000000000001))), type_: Contract, body: V0(ContractEventV0 { topics: VecM([Symbol(ScSymbol(StringM(transfer))), Address(Contract(ContractId(Hash(0000000000000000000000000000000000000000000000000000000000000002)))), Address(Account(AccountId(PublicKeyTypeEd25519(Uint256(0000000000000000000000000000000000000000000000000000000000000003)))))]), data: Map(Some(ScMap(VecM([ScMapEntry { key: Symbol(ScSymbol(StringM(amount))), val: I128(Int128Parts { hi: 0, lo: 0 }) }, ScMapEntry { key: Symbol(ScSymbol(StringM(to_muxed_id))), val: U64(1) }])))) }) }]
```

An example test:

```rust
    #[test]
    fn test_event() {
        let env = Env::default();
        let contract_id = env.register(Contract, ());
        let client = ContractClient::new(&env, &contract_id);

        let from = Address::generate(&env);
        let to = MuxedAddress::generate(&env);
        let amount = 1i128;

        client.transfer(&from, &to, &amount);

        assert_eq!(
            env.events().all(),
            std::vec![Transfer {
                from: from.clone(),
                to: to.address(),
                amount,
                to_muxed_id: to.id(),
            }
            .to_contract_event(&env, &contract_id)],
        );
    }
```


### Why

Solves #1566. Makes it easier to validate events during tests. 

### Known limitations

None

---------

Co-authored-by: Leigh <351529+leighmcculloch@users.noreply.github.com>

Author: mootz12

soroban-sdk/src/events.rs

@@ -58,13 +58,31 @@ impl Debug for Events {
     }
 }
 
+#[cfg(any(test, feature = "testutils"))]
+use crate::{testutils, xdr, FromVal};
+
 pub trait Event {
     fn topics(&self, env: &Env) -> Vec<Val>;
     fn data(&self, env: &Env) -> Val;
 
     fn publish(&self, env: &Env) {
         env.events().publish_event(self);
     }
+
+    /// Convert this event and the given contract_id into a [`xdr::ContractEvent`] object.
+    /// Used to compare Events to emitted events in tests.
+    #[cfg(any(test, feature = "testutils"))]
+    fn to_xdr(&self, env: &Env, contract_id: &crate::Address) -> xdr::ContractEvent {
+        xdr::ContractEvent {
+            ext: xdr::ExtensionPoint::V0,
+            type_: xdr::ContractEventType::Contract,
+            contract_id: Some(contract_id.contract_id()),
+            body: xdr::ContractEventBody::V0(xdr::ContractEventV0 {
+                topics: self.topics(env).into(),
+                data: xdr::ScVal::from_val(env, &self.data(env)),
+            }),
+        }
+    }
 }
 
 pub trait Topics: IntoVal<Env, Vec<Val>> {}
@@ -116,39 +134,29 @@ impl Events {
     }
 }
 
-#[cfg(any(test, feature = "testutils"))]
-use crate::{testutils, xdr, Address, TryIntoVal};
-
 #[cfg(any(test, feature = "testutils"))]
 #[cfg_attr(feature = "docs", doc(cfg(feature = "testutils")))]
 impl testutils::Events for Events {
-    fn all(&self) -> Vec<(crate::Address, Vec<Val>, Val)> {
+    fn all(&self) -> testutils::ContractEvents {
         let env = self.env();
-        let mut vec = Vec::new(env);
-        self.env()
+        let vec: std::vec::Vec<xdr::ContractEvent> = self
+            .env()
             .host()
             .get_events()
             .unwrap()
             .0
             .into_iter()
-            .for_each(|e| {
-                if e.failed_call {
-                    return;
-                }
-                if let xdr::ContractEvent {
-                    type_: xdr::ContractEventType::Contract,
-                    contract_id: Some(contract_id),
-                    body: xdr::ContractEventBody::V0(xdr::ContractEventV0 { topics, data }),
-                    ..
-                } = e.event
+            .filter_map(|e| {
+                if !e.failed_call
+                    && e.event.type_ == xdr::ContractEventType::Contract
+                    && e.event.contract_id.is_some()
                 {
-                    vec.push_back((
-                        Address::from_contract_id(env, contract_id.0 .0),
-                        topics.try_into_val(env).unwrap(),
-                        data.try_into_val(env).unwrap(),
-                    ))
+                    Some(e.event)
+                } else {
+                    None
                 }
-            });
-        vec
+            })
+            .collect();
+        testutils::ContractEvents::new(&env, vec)
     }
 }