diff --git a/.claude/commands/code-quality.md b/.claude/commands/code-quality.md index 08b7fa6ec..d314d0ab5 100644 --- a/.claude/commands/code-quality.md +++ b/.claude/commands/code-quality.md @@ -259,8 +259,8 @@ followed by `mod contract;` and `#[cfg(test)] mod test;`. - Crate name: `stellar-` (`stellar-access`, `stellar-tokens`). Internal Rust module names are snake_case. - All library packages are `#![no_std]`. `[dependencies]` must not pull in - `std`-only crates. The `[dev-dependencies]` block may - (`stellar-event-assertion`, `soroban-sdk` with `testutils`). + `std`-only crates. The `[dev-dependencies]` block may (`soroban-sdk` with + `testutils`). - Workspace fields use the `field.workspace = true` shorthand (`edition.workspace = true`, `version.workspace = true`, `license.workspace = true`, `repository.workspace = true`, @@ -493,9 +493,13 @@ followed by `mod contract;` and `#[cfg(test)] mod test;`. test through it. - Authorisation in tests uses `e.mock_all_auths()` — never hand-build auth payloads unless explicitly testing the auth machinery. -- Event assertions use `EventAssertion::new(&e, address.clone())` from the - `stellar-event-assertion` dev-dependency. Hand-decoding - `e.events().all()` is a violation when an `assert_*` helper exists. +- Event assertions compare the emitted entry against the typed + `#[contractevent]` struct serialized with `.to_xdr(&e, &address)`, e.g. + `assert_eq!(events.events().first().unwrap(), &Transfer { .. }.to_xdr(&e, &address))`, + with the count checked via `e.events().all().events().len()`. Use + `.first()` for index 0 and `.get(i)` afterwards. Hand-decoding topics/data + field-by-field out of `e.events().all()` is a violation — build the event + struct and let `to_xdr` produce the wire form. - Panic tests use `#[should_panic(expected = "Error(Contract, #)")]` — the numeric code must match the `#[repr(u32)]` value of the expected enum variant. diff --git a/Architecture.md b/Architecture.md index 18162dba4..d4ccc966c 100644 --- a/Architecture.md +++ b/Architecture.md @@ -14,7 +14,6 @@ stellar-contracts/ │ ├── access/ # Role-based access controls and ownable patterns │ ├── contract-utils/ # Utilities (pausable, upgradeable, cryptography) │ ├── macros/ # Procedural and derive macros -│ ├── test-utils/ # Testing utilities and helpers │ └── tokens/ # Token implementations (fungible, non-fungible) │ ├── src/ │ │ ├── fungible/ # Fungible token implementation diff --git a/CLAUDE.md b/CLAUDE.md index 4dcc76dae..fe4b9bd9b 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -13,7 +13,6 @@ packages/ ├── fee-abstraction/ # fee forwarder ├── governance/ # governor, timelock, votes ├── macros/ # only_owner / only_role / when_paused, etc. -├── test-utils/ # event-assertion helper crate ├── tokens/ # fungible + non_fungible + rwa + vault └── zk-email/ # zk-email auth primitives examples/ # one example crate per feature; cdylib only @@ -176,9 +175,20 @@ Reversing the two is a common mistake. - Library-internal calls go inside `e.as_contract(&address, || { ... })`; example tests go through the generated `ExampleContractClient`. -- Event assertions: `EventAssertion::new(&e, address.clone())` from - `stellar-event-assertion`. Hand-decoding `e.events().all()` is a - violation when an `assert_*` helper exists. +- Event assertions: compare the emitted entry against the typed + `#[contractevent]` struct serialized with `.to_xdr(&e, &address)`: + ```rust + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &Transfer { from: from.clone(), to: to.clone(), amount }.to_xdr(&e, &address), + ); + ``` + Use `.first()` for index 0 and `.get(i)` for later events (clippy's + `get_first` rejects `.get(0)`). Hand-decoding topics/data out of + `e.events().all()` field-by-field is a violation — build the event + struct and let `to_xdr` produce the wire form. - Panic tests use the numeric form: `#[should_panic(expected = "Error(Contract, #)")]`. diff --git a/Cargo.lock b/Cargo.lock index 6b5f4f5dc..c3e63ea44 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2384,7 +2384,6 @@ name = "stellar-access" version = "0.7.1" dependencies = [ "soroban-sdk", - "stellar-event-assertion", ] [[package]] @@ -2398,7 +2397,6 @@ dependencies = [ "serde-json-core", "soroban-sdk", "soroban-test-helpers", - "stellar-event-assertion", ] [[package]] @@ -2412,15 +2410,6 @@ dependencies = [ "hex-literal 1.1.0", "proptest", "soroban-sdk", - "stellar-event-assertion", -] - -[[package]] -name = "stellar-event-assertion" -version = "0.7.1" -dependencies = [ - "soroban-sdk", - "stellar-tokens", ] [[package]] @@ -2480,7 +2469,6 @@ dependencies = [ "soroban-sdk", "soroban-test-helpers", "stellar-contract-utils", - "stellar-event-assertion", "stellar-governance", ] diff --git a/Cargo.toml b/Cargo.toml index b21e0986c..d938d5630 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,7 +33,6 @@ members = [ "packages/fee-abstraction", "packages/governance", "packages/macros", - "packages/test-utils/*", "packages/tokens", "packages/zk-email", ] @@ -73,7 +72,6 @@ serde-json-core = { version = "0.6.0", default-features = false } stellar-access = { path = "packages/access", version = "0.7.1" } stellar-accounts = { path = "packages/accounts", version = "0.7.1" } stellar-contract-utils = { path = "packages/contract-utils", version = "0.7.1" } -stellar-event-assertion = { path = "packages/test-utils/event-assertion" } stellar-fee-abstraction = { path = "packages/fee-abstraction", version = "0.7.1" } stellar-governance = { path = "packages/governance", version = "0.7.1" } stellar-tokens = { path = "packages/tokens", version = "0.7.1" } diff --git a/README.md b/README.md index 979461ea7..253ed1941 100644 --- a/README.md +++ b/README.md @@ -35,7 +35,6 @@ Refer to the [OpenZeppelin for Stellar Contracts](https://docs.openzeppelin.com/ - [`fee-abstraction/`](packages/fee-abstraction): Utilities for covering transaction fees with fungible tokens instead of XLM - [`governance/`](packages/governance): Governance utilities (governor, votes, timelock) - [`macros/`](packages/macros): Proc macros for some of the modules (`#[only_owner]`, `#[when_not_paused]`, etc.) - - [`test-utils/`](packages/test-utils): Utilities for testing - [`tokens/`](packages/tokens): Various token types (fungible, non-fungible, real-world assets, vaults) - [`zk-email/`](packages/zk-email): On-chain DKIM registry for zkEmail verification - `examples/`: Example contracts diff --git a/packages/access/Cargo.toml b/packages/access/Cargo.toml index ebdc45c1d..9cc058a94 100644 --- a/packages/access/Cargo.toml +++ b/packages/access/Cargo.toml @@ -20,4 +20,3 @@ soroban-sdk = { workspace = true } [dev-dependencies] soroban-sdk = { workspace = true, features = ["testutils"] } -stellar-event-assertion = { workspace = true } diff --git a/packages/access/src/access_control/test.rs b/packages/access/src/access_control/test.rs index 433f54997..9854357d8 100644 --- a/packages/access/src/access_control/test.rs +++ b/packages/access/src/access_control/test.rs @@ -2,10 +2,9 @@ extern crate std; use soroban_sdk::{ contract, symbol_short, - testutils::{Address as _, Ledger}, + testutils::{Address as _, Events, Ledger}, Address, Env, Symbol, }; -use stellar_event_assertion::EventAssertion; use crate::access_control::{ accept_admin_transfer, add_to_role_enumeration, ensure_if_admin_or_admin_role, get_admin, @@ -38,8 +37,7 @@ fn admin_functions_work() { assert!(has_role(&e, &user, &USER_ROLE).is_some()); // Test events - let event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); e.as_contract(&address, || { @@ -48,8 +46,7 @@ fn admin_functions_work() { assert!(has_role(&e, &user, &USER_ROLE).is_none()); // Test events - let event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -223,8 +220,7 @@ fn admin_transfer_works_with_admin_auth() { assert_eq!(get_admin(&e), Some(new_admin)); // Verify events - let event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -246,8 +242,7 @@ fn admin_transfer_cancel_works() { transfer_admin_role(&e, &new_admin, 1000); // Verify events - let event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); e.as_contract(&address, || { @@ -258,8 +253,7 @@ fn admin_transfer_cancel_works() { assert_eq!(get_admin(&e), Some(admin)); // Verify events - let event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } diff --git a/packages/access/src/ownable/test.rs b/packages/access/src/ownable/test.rs index 8aab3f835..5cc25ad9b 100644 --- a/packages/access/src/ownable/test.rs +++ b/packages/access/src/ownable/test.rs @@ -2,10 +2,9 @@ extern crate std; use soroban_sdk::{ contract, - testutils::{Address as _, Ledger}, + testutils::{Address as _, Events, Ledger}, Address, Env, }; -use stellar_event_assertion::EventAssertion; use crate::{ ownable::{ @@ -38,8 +37,7 @@ fn transfer_ownership_sets_pending() { e.storage().temporary().get(&OwnableStorageKey::PendingOwner); assert_eq!(pending.map(|p| p.address), Some(new_owner)); - let assert = EventAssertion::new(&e, contract.clone()); - assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -61,8 +59,7 @@ fn accept_ownership_completes_transfer() { let stored_owner = get_owner(&e); assert_eq!(stored_owner, Some(new_owner)); - let assert = EventAssertion::new(&e, contract.clone()); - assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -83,8 +80,7 @@ fn renounce_ownership_removes_owner() { assert_eq!(get_owner(&e), None); - let assert = EventAssertion::new(&e, contract.clone()); - assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } diff --git a/packages/accounts/Cargo.toml b/packages/accounts/Cargo.toml index 7325eab14..6bd3d2c38 100644 --- a/packages/accounts/Cargo.toml +++ b/packages/accounts/Cargo.toml @@ -22,7 +22,6 @@ serde-json-core = { workspace = true } [dev-dependencies] soroban-sdk = { workspace = true, features = ["testutils"] } soroban-test-helpers = { workspace = true } -stellar-event-assertion = { workspace = true } ed25519-dalek = { workspace = true } p256 = { workspace = true, features = ["ecdsa"] } hex-literal = { workspace = true } diff --git a/packages/contract-utils/Cargo.toml b/packages/contract-utils/Cargo.toml index 729b3cb01..5a8cc94ac 100644 --- a/packages/contract-utils/Cargo.toml +++ b/packages/contract-utils/Cargo.toml @@ -22,7 +22,6 @@ soroban-sdk = { workspace = true } soroban-sdk = { workspace = true, features = ["testutils"] } proptest = { workspace = true } hex-literal = { workspace = true } -stellar-event-assertion = { workspace = true } ark-grumpkin = { version = "0.6", default-features = false } ark-ec = { version = "0.6", default-features = false } ark-ff = { version = "0.6", default-features = false } diff --git a/packages/contract-utils/src/merkle_distributor/test.rs b/packages/contract-utils/src/merkle_distributor/test.rs index b7185fe1d..c0b4193b3 100644 --- a/packages/contract-utils/src/merkle_distributor/test.rs +++ b/packages/contract-utils/src/merkle_distributor/test.rs @@ -2,9 +2,10 @@ extern crate std; use hex_literal::hex; use soroban_sdk::{ - contract, contracttype, testutils::Address as _, vec, Address, BytesN, Env, Vec, + contract, contracttype, + testutils::{Address as _, Events}, + vec, Address, BytesN, Env, Vec, }; -use stellar_event_assertion::EventAssertion; use crate::{ crypto::sha256::Sha256, @@ -96,13 +97,11 @@ fn test_set_root_and_successful_claim_emits_events() { Distributor::set_root(&e, root.clone()); assert_eq!(Distributor::get_root(&e), root); - let assert = EventAssertion::new(&e, address.clone()); - assert.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); // Set claimed and verify event Distributor::set_claimed(&e, 1); - let assert = EventAssertion::new(&e, address.clone()); - assert.assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/test-utils/event-assertion/Cargo.toml b/packages/test-utils/event-assertion/Cargo.toml deleted file mode 100644 index 2d82e67cd..000000000 --- a/packages/test-utils/event-assertion/Cargo.toml +++ /dev/null @@ -1,19 +0,0 @@ -[package] -name = "stellar-event-assertion" -edition.workspace = true -license.workspace = true -repository.workspace = true -publish = false -version.workspace = true - -[package.metadata.stellar] -cargo_inherit = true - -[lib] -crate-type = ["lib"] -doctest = false - -# This crate is only used for testing, and not compatible with `wasm32` targets. -[target.'cfg(not(target_family = "wasm"))'.dependencies] -soroban-sdk = { workspace = true, features = ["testutils"] } -stellar-tokens = { workspace = true } diff --git a/packages/test-utils/event-assertion/src/lib.rs b/packages/test-utils/event-assertion/src/lib.rs deleted file mode 100644 index 7232aa291..000000000 --- a/packages/test-utils/event-assertion/src/lib.rs +++ /dev/null @@ -1,402 +0,0 @@ -// A conditional attribute that applies `no_std` only for wasm targets. -// This prevents Cargo from implicitly injecting std::prelude imports into empty -// crates when building for wasm targets that don't support std (like -// wasm32v1-none). -#![cfg_attr(target_family = "wasm", no_std)] - -// The entire implementation is only compiled for non-wasm targets. -// This is a test utility crate that's not needed in wasm environments. -#[cfg(not(target_family = "wasm"))] -mod implementation { - use std::collections::HashSet; - - use soroban_sdk::{ - symbol_short, testutils::Events, xdr, Address, Env, FromVal, IntoVal, Map, Symbol, - TryFromVal, Val, - }; - - pub struct EventAssertion<'a> { - env: &'a Env, - contract: Address, - processed_events: HashSet, - } - - impl<'a> EventAssertion<'a> { - pub fn new(env: &'a Env, contract: Address) -> Self { - Self { env, contract, processed_events: HashSet::new() } - } - - fn expect_event(&mut self, symbol_name: &str, missing_message: &str) -> xdr::ContractEvent { - self.find_event_by_symbol(symbol_name).expect(missing_message) - } - - fn assert_event_contract(&self, event: &xdr::ContractEvent) { - assert_eq!(event.contract_id, Some(self.contract_id()), "Event from wrong contract"); - } - - fn contract_id(&self) -> xdr::ContractId { - match xdr::ScAddress::from(&self.contract) { - xdr::ScAddress::Contract(contract_id) => contract_id, - _ => panic!("expected contract address"), - } - } - - fn event_topics_data<'b>( - &self, - event: &'b xdr::ContractEvent, - ) -> (&'b xdr::VecM, &'b xdr::ScVal) { - match &event.body { - xdr::ContractEventBody::V0(body) => (&body.topics, &body.data), - } - } - - fn topic_as>( - &self, - topics: &xdr::VecM, - index: usize, - ) -> T { - T::from_val(self.env, topics.get(index).unwrap()) - } - - fn topic_as_val>( - &self, - topics: &xdr::VecM, - index: usize, - ) -> T { - let val = Val::try_from_val(self.env, topics.get(index).unwrap()).unwrap(); - T::from_val(self.env, &val) - } - - fn assert_topic_symbol( - &self, - topics: &xdr::VecM, - index: usize, - expected: Symbol, - ) { - let topic_symbol: Symbol = self.topic_as(topics, index); - assert_eq!(topic_symbol, expected); - } - - fn find_event_by_symbol(&mut self, symbol_name: &str) -> Option { - let events = self.env.events().all(); - - let target_symbol = match symbol_name { - "transfer" => symbol_short!("transfer"), - "mint" => symbol_short!("mint"), - "burn" => symbol_short!("burn"), - "approve" => symbol_short!("approve"), - _ => Symbol::new(self.env, symbol_name), - }; - - for (index, event) in events.events().iter().enumerate() { - let index_u32 = index as u32; - - if self.processed_events.contains(&index_u32) { - continue; - } - - let (topics, _data) = self.event_topics_data(event); - - if let Some(first_topic) = topics.first() { - let topic_symbol: Symbol = Symbol::from_val(self.env, first_topic); - - if topic_symbol == target_symbol { - self.processed_events.insert(index_u32); - return Some(event.clone()); - } - } - } - None - } - - /// Asserts a SEP-41 transfer event with a bare `i128` data field - /// (no muxed ID). This is the standard shape for `transfer` to a - /// non-muxed address, `transfer_from`, and RWA transfers. - pub fn assert_fungible_transfer(&mut self, from: &Address, to: &Address, amount: i128) { - let event = self.expect_event("transfer", "Transfer event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 3, "Transfer event should have 3 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("transfer")); - - let event_from: Address = self.topic_as(topics, 1); - let event_to: Address = self.topic_as(topics, 2); - - let val = Val::try_from_val(self.env, data).unwrap(); - let event_amount: i128 = i128::from_val(self.env, &val); - - assert_eq!(&event_from, from, "Transfer event has wrong from address"); - assert_eq!(&event_to, to, "Transfer event has wrong to address"); - assert_eq!(event_amount, amount, "Transfer event has wrong amount"); - } - - /// Asserts a SEP-41 muxed transfer event whose data field is - /// `{to_muxed_id: Option, amount: i128}`. - pub fn assert_fungible_muxed_transfer( - &mut self, - from: &Address, - to: &Address, - muxed_id: Option, - amount: i128, - ) { - let event = self.expect_event("transfer", "Transfer event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 3, "Transfer event should have 3 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("transfer")); - - let event_from: Address = self.topic_as(topics, 1); - let event_to: Address = self.topic_as(topics, 2); - - let data_map: Map = Map::from_val(self.env, data); - let event_amount: i128 = - data_map.get(symbol_short!("amount")).unwrap().into_val(self.env); - let event_muxed_id: Option = - data_map.get(Symbol::new(self.env, "to_muxed_id")).unwrap().into_val(self.env); - - assert_eq!(&event_from, from, "Transfer event has wrong from address"); - assert_eq!(&event_to, to, "Transfer event has wrong to address"); - assert_eq!(event_amount, amount, "Transfer event has wrong amount"); - assert_eq!(event_muxed_id, muxed_id, "Transfer event has wrong muxed id"); - } - - pub fn assert_non_fungible_transfer( - &mut self, - from: &Address, - to: &Address, - token_id: u32, - ) { - let event = self.expect_event("transfer", "Transfer event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 3, "Transfer event should have 3 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("transfer")); - - let event_from: Address = self.topic_as(topics, 1); - let event_to: Address = self.topic_as(topics, 2); - - let data_map: Map = Map::from_val(self.env, data); - let event_token_id = data_map.get(Symbol::new(self.env, "token_id")).unwrap(); - - assert_eq!(&event_from, from, "Transfer event has wrong from address"); - assert_eq!(&event_to, to, "Transfer event has wrong to address"); - assert_eq!(event_token_id, token_id, "Transfer event has wrong amount"); - } - - pub fn assert_fungible_mint(&mut self, to: &Address, amount: i128) { - let event = self.expect_event("mint", "Mint event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 2, "Mint event should have 2 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("mint")); - - let event_to: Address = self.topic_as(topics, 1); - - let data_map: Map = Map::from_val(self.env, data); - let event_amount = data_map.get(Symbol::new(self.env, "amount")).unwrap(); - - assert_eq!(&event_to, to, "Mint event has wrong to address"); - assert_eq!(event_amount, amount, "Mint event has wrong amount"); - } - - pub fn assert_non_fungible_mint(&mut self, to: &Address, token_id: u32) { - let event = self.expect_event("mint", "Mint event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 2, "Mint event should have 2 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("mint")); - - let event_to: Address = self.topic_as(topics, 1); - - let data_map: Map = Map::from_val(self.env, data); - let event_token_id = data_map.get(Symbol::new(self.env, "token_id")).unwrap(); - - assert_eq!(&event_to, to, "Mint event has wrong to address"); - assert_eq!(event_token_id, token_id, "Mint event has wrong token_id"); - } - - pub fn assert_fungible_burn(&mut self, from: &Address, amount: i128) { - let event = self.expect_event("burn", "Burn event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 2, "Burn event should have 2 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("burn")); - - let event_from: Address = self.topic_as(topics, 1); - - let data_map: Map = Map::from_val(self.env, data); - let event_amount = data_map.get(Symbol::new(self.env, "amount")).unwrap(); - - assert_eq!(&event_from, from, "Burn event has wrong from address"); - assert_eq!(event_amount, amount, "Burn event has wrong amount"); - } - - pub fn assert_non_fungible_burn(&mut self, from: &Address, token_id: u32) { - let event = self.expect_event("burn", "Burn event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 2, "Burn event should have 2 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("burn")); - - let event_from: Address = self.topic_as(topics, 1); - - let data_map: Map = Map::from_val(self.env, data); - let event_token_id = data_map.get(Symbol::new(self.env, "token_id")).unwrap(); - - assert_eq!(&event_from, from, "Burn event has wrong from address"); - assert_eq!(event_token_id, token_id, "Burn event has wrong token_id"); - } - - pub fn assert_event_count(&self, expected: usize) { - let events = self.env.events().all(); - let event_count = events.events().len(); - assert_eq!( - event_count, expected, - "Expected {} events, found {}", - expected, event_count - ); - } - - pub fn assert_fungible_approve( - &mut self, - owner: &Address, - spender: &Address, - amount: i128, - live_until_ledger: u32, - ) { - let event = self.expect_event("approve", "Approve event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 3, "Approve event should have 3 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("approve")); - - let event_owner: Address = self.topic_as(topics, 1); - let event_spender: Address = self.topic_as(topics, 2); - - let data_map: Map = Map::from_val(self.env, data); - let event_amount: i128 = - data_map.get(Symbol::new(self.env, "amount")).unwrap().into_val(self.env); - let event_live_until_ledger: u32 = data_map - .get(Symbol::new(self.env, "live_until_ledger")) - .unwrap() - .into_val(self.env); - - assert_eq!(&event_owner, owner, "Approve event has wrong owner address"); - assert_eq!(&event_spender, spender, "Approve event has wrong spender address"); - assert_eq!(event_amount, amount, "Approve event has wrong amount"); - assert_eq!( - event_live_until_ledger, live_until_ledger, - "Approve event has wrong live_until_ledger" - ); - } - - pub fn assert_non_fungible_approve( - &mut self, - owner: &Address, - spender: &Address, - token_id: u32, - live_until_ledger: u32, - ) { - let event = self.expect_event("approve", "Approve event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 3, "Approve event should have 3 topics"); - - self.assert_topic_symbol(topics, 0, symbol_short!("approve")); - - let event_owner: Address = self.topic_as(topics, 1); - let event_token_id: u32 = self.topic_as_val(topics, 2); - - let data_map: Map = Map::from_val(self.env, data); - let event_approved: Address = - data_map.get(Symbol::new(self.env, "approved")).unwrap().into_val(self.env); - let event_live_until_ledger: u32 = data_map - .get(Symbol::new(self.env, "live_until_ledger")) - .unwrap() - .into_val(self.env); - - assert_eq!(&event_owner, owner, "Approve event has wrong owner address"); - assert_eq!(event_token_id, token_id, "Approve event has wrong token_id"); - assert_eq!(event_approved, *spender, "Approve event has wrong approved address"); - assert_eq!( - event_live_until_ledger, live_until_ledger, - "Approve event has wrong live_until_ledger" - ); - } - - pub fn assert_approve_for_all( - &mut self, - owner: &Address, - operator: &Address, - live_until_ledger: u32, - ) { - let event = - self.expect_event("approve_for_all", "ApproveForAll event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 2, "ApproveForAll event should have 2 topics"); - - self.assert_topic_symbol(topics, 0, Symbol::new(self.env, "approve_for_all")); - - let event_owner: Address = self.topic_as(topics, 1); - - let data_map: Map = Map::from_val(self.env, data); - let event_operator: Address = - data_map.get(Symbol::new(self.env, "operator")).unwrap().into_val(self.env); - let event_live_until_ledger: u32 = data_map - .get(Symbol::new(self.env, "live_until_ledger")) - .unwrap() - .into_val(self.env); - - assert_eq!(&event_owner, owner, "ApproveForAll event has wrong owner address"); - assert_eq!(event_operator, *operator, "ApproveForAll event has wrong operator address"); - assert_eq!( - event_live_until_ledger, live_until_ledger, - "ApproveForAll event has wrong live_until_ledger" - ); - } - - pub fn assert_consecutive_mint(&mut self, to: &Address, from_id: u32, to_id: u32) { - let event = self - .expect_event("consecutive_mint", "ConsecutiveMint event not found in event log"); - self.assert_event_contract(&event); - - let (topics, data) = self.event_topics_data(&event); - assert_eq!(topics.len(), 2, "ConsecutiveMint event should have 2 topics"); - - self.assert_topic_symbol(topics, 0, Symbol::new(self.env, "consecutive_mint")); - - let event_to: Address = self.topic_as(topics, 1); - - let data_map: Map = Map::from_val(self.env, data); - let from_token_id_val = data_map.get(Symbol::new(self.env, "from_token_id")).unwrap(); - let to_token_id_val = data_map.get(Symbol::new(self.env, "to_token_id")).unwrap(); - - assert_eq!(&event_to, to, "ConsecutiveMint event has wrong to address"); - assert_eq!(from_token_id_val, from_id, "ConsecutiveMint event has wrong from_token_id"); - assert_eq!(to_token_id_val, to_id, "ConsecutiveMint event has wrong to_token_id"); - } - } -} - -// Re-export for non-wasm targets -#[cfg(not(target_family = "wasm"))] -pub use implementation::*; diff --git a/packages/tokens/Cargo.toml b/packages/tokens/Cargo.toml index 37e61159d..7168b3ddb 100644 --- a/packages/tokens/Cargo.toml +++ b/packages/tokens/Cargo.toml @@ -24,6 +24,5 @@ stellar-governance = { workspace = true } ed25519-dalek = { workspace = true } soroban-sdk = { workspace = true, features = ["testutils"] } soroban-test-helpers = { workspace = true } -stellar-event-assertion = { workspace = true } k256 = { workspace = true, features = ["ecdsa"] } p256 = { workspace = true, features = ["ecdsa"] } diff --git a/packages/tokens/src/confidential/auditor/test.rs b/packages/tokens/src/confidential/auditor/test.rs index 4bb4ca701..406c8d6dc 100644 --- a/packages/tokens/src/confidential/auditor/test.rs +++ b/packages/tokens/src/confidential/auditor/test.rs @@ -1,8 +1,7 @@ extern crate std; -use soroban_sdk::{contract, BytesN, Env}; +use soroban_sdk::{contract, testutils::Events, BytesN, Env}; use stellar_contract_utils::crypto::grumpkin::Grumpkin; -use stellar_event_assertion::EventAssertion; use crate::confidential::auditor::storage::{ get_key, register_key, rotate_key, validate_point, AuditorStorageKey, @@ -49,8 +48,7 @@ fn register_and_get_key_works() { assert_eq!(get_key(&e, 1), p); - let assertion = EventAssertion::new(&e, address.clone()); - assertion.assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -224,7 +222,7 @@ fn rotate_emits_rotation_event() { rotate_key(&e, 1, &new); // 2 events: AuditorRegistered + AuditorRotated. - EventAssertion::new(&e, address.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/tokens/src/confidential/compliance/test.rs b/packages/tokens/src/confidential/compliance/test.rs index 03059cc92..c0a5ff224 100644 --- a/packages/tokens/src/confidential/compliance/test.rs +++ b/packages/tokens/src/confidential/compliance/test.rs @@ -2,12 +2,11 @@ extern crate std; use soroban_sdk::{ contract, contractimpl, - testutils::Address as _, + testutils::{Address as _, Events}, token::StellarAssetClient, xdr::{AccountFlags, ToXdr}, Address, Bytes, BytesN, Env, IntoVal, Val, }; -use stellar_event_assertion::EventAssertion; use crate::confidential::{ compliance::{ @@ -252,7 +251,7 @@ fn freeze_then_unfreeze_round_trip() { }); // 1 ComplianceConfigChanged + 1 Frozen + 1 Unfrozen. - EventAssertion::new(&h.e, h.host.clone()).assert_event_count(3); + assert_eq!(h.e.events().all().events().len(), 3); } #[test] @@ -525,7 +524,7 @@ fn set_compliance_config_overwrites_atomically() { }); // 2 ComplianceConfigChanged events. - EventAssertion::new(&h.e, h.host.clone()).assert_event_count(2); + assert_eq!(h.e.events().all().events().len(), 2); } // ################## COMBINED GATES ################## diff --git a/packages/tokens/src/confidential/test.rs b/packages/tokens/src/confidential/test.rs index 81c6de06a..34095446e 100644 --- a/packages/tokens/src/confidential/test.rs +++ b/packages/tokens/src/confidential/test.rs @@ -2,12 +2,11 @@ extern crate std; use soroban_sdk::{ contract, contractimpl, - testutils::{Address as _, Ledger}, + testutils::{Address as _, Events, Ledger}, token::StellarAssetClient, xdr::ToXdr, Address, Bytes, BytesN, Env, }; -use stellar_event_assertion::EventAssertion; use crate::confidential::{ auditor::{storage as auditor_storage, ConfidentialAuditor}, @@ -261,7 +260,7 @@ fn register_stores_account_with_identity_balances() { let alice = Address::generate(&h.e); h.token.register(&alice, &1u32, ®ister_data(&h.e)); - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(1); + assert_eq!(h.e.events().all().events().len(), 1); let account: ConfidentialAccount = h.token.confidential_balance(&alice); assert_eq!(account.spending_key, fixture_point(&h.e)); @@ -373,7 +372,7 @@ fn deposit_credits_receiving_balance() { h.token.deposit(&depositor, &alice, &500i128); // 1 SAC transfer event + 1 Deposit event. - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(2); + assert_eq!(h.e.events().all().events().len(), 2); // Receiving balance must move off identity. let account = h.token.confidential_balance(&alice); @@ -437,7 +436,7 @@ fn merge_folds_receiving_into_spendable() { let pre = h.token.confidential_balance(&alice); h.token.merge(&alice); - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(1); + assert_eq!(h.e.events().all().events().len(), 1); let post = h.token.confidential_balance(&alice); @@ -471,7 +470,7 @@ fn withdraw_transfers_tokens_and_updates_spendable() { h.token.withdraw(&alice, &beneficiary, &300i128, &withdraw_data(&h.e)); // 1 SAC transfer event + 1 Withdraw event. - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(2); + assert_eq!(h.e.events().all().events().len(), 2); let token_client = soroban_sdk::token::TokenClient::new(&h.e, &h.sac_addr); assert_eq!(token_client.balance(&beneficiary), 300); @@ -519,7 +518,7 @@ fn confidential_transfer_updates_both_sides() { h.token.merge(&alice); h.token.confidential_transfer(&alice, &bob, &transfer_data(&h.e)); - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(1); + assert_eq!(h.e.events().all().events().len(), 1); // Sender's spendable balance was overwritten. let alice_acc = h.token.confidential_balance(&alice); @@ -541,7 +540,7 @@ fn set_spender_stores_delegation() { h.token.register(&spender, &1u32, ®ister_data(&h.e)); h.token.set_spender(&alice, &spender, &1_000u32, &set_spender_data(&h.e)); - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(1); + assert_eq!(h.e.events().all().events().len(), 1); let delegation = h.token.get_spender_delegation(&alice, &spender); assert_eq!(delegation.live_until_ledger, 1_000); @@ -572,7 +571,7 @@ fn revoke_spender_deletes_delegation() { h.token.set_spender(&alice, &spender, &1_000u32, &set_spender_data(&h.e)); h.token.revoke_spender(&alice, &spender, &revoke_spender_data(&h.e)); - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(1); + assert_eq!(h.e.events().all().events().len(), 1); assert!(!h.token.is_spender(&alice, &spender)); } @@ -611,7 +610,7 @@ fn confidential_transfer_from_updates_delegation_and_recipient() { h.token.set_spender(&alice, &spender, &1_000u32, &set_spender_data(&h.e)); h.token.confidential_transfer_from(&spender, &alice, &bob, &spender_transfer_data(&h.e)); - EventAssertion::new(&h.e, h.token_addr.clone()).assert_event_count(1); + assert_eq!(h.e.events().all().events().len(), 1); // Delegation allowance commitment was rotated. let delegation = h.token.get_spender_delegation(&alice, &spender); @@ -720,7 +719,7 @@ fn set_underlying_asset_emits_event() { let token = Address::generate(&e); e.as_contract(&bare, || { token_storage::set_underlying_asset(&e, &token); - EventAssertion::new(&e, bare.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -731,7 +730,7 @@ fn set_verifier_emits_event() { let verifier = Address::generate(&e); e.as_contract(&bare, || { token_storage::set_verifier(&e, &verifier); - EventAssertion::new(&e, bare.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -742,7 +741,7 @@ fn set_auditor_emits_event() { let auditor = Address::generate(&e); e.as_contract(&bare, || { token_storage::set_auditor(&e, &auditor); - EventAssertion::new(&e, bare.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -752,7 +751,7 @@ fn set_address_as_field_element_emits_event() { let bare = e.register(BareContract, ()); e.as_contract(&bare, || { token_storage::set_address_as_field_element(&e); - EventAssertion::new(&e, bare.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } diff --git a/packages/tokens/src/confidential/verifier/test.rs b/packages/tokens/src/confidential/verifier/test.rs index 78d4352d2..2b0cf226b 100644 --- a/packages/tokens/src/confidential/verifier/test.rs +++ b/packages/tokens/src/confidential/verifier/test.rs @@ -1,7 +1,6 @@ extern crate std; -use soroban_sdk::{contract, Bytes, Env}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{contract, testutils::Events, Bytes, Env}; use crate::confidential::verifier::{ storage::{ @@ -29,7 +28,7 @@ fn register_and_get_verification_key_works() { assert_eq!(get_verification_key(&e, CircuitType::Register), vk); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -120,7 +119,7 @@ fn update_emits_update_event() { update_verification_key(&e, CircuitType::SpenderTransfer, &new); // 2 events: VerificationKeyRegistered + VerificationKeyUpdated. - EventAssertion::new(&e, address.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/tokens/src/fungible/extensions/burnable/test.rs b/packages/tokens/src/fungible/extensions/burnable/test.rs index c7241e742..639b70d9f 100644 --- a/packages/tokens/src/fungible/extensions/burnable/test.rs +++ b/packages/tokens/src/fungible/extensions/burnable/test.rs @@ -1,9 +1,12 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, Address, Env}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + Address, Env, Event, +}; -use crate::fungible::Base; +use crate::fungible::{extensions::burnable::Burn, Approve, Base, Mint}; #[contract] struct MockContract; @@ -20,10 +23,16 @@ fn burn_works() { assert_eq!(Base::balance(&e, &account), 50); assert_eq!(Base::total_supply(&e), 50); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_fungible_mint(&account, 100); - event_assert.assert_fungible_burn(&account, 50); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: account.clone(), amount: 100 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Burn { from: account.clone(), amount: 50 }.to_xdr(&e, &address) + ); }); } @@ -42,11 +51,26 @@ fn burn_with_allowance_works() { assert_eq!(Base::balance(&e, &spender), 0); assert_eq!(Base::total_supply(&e), 70); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_fungible_mint(&owner, 100); - event_assert.assert_fungible_approve(&owner, &spender, 30, 1000); - event_assert.assert_fungible_burn(&owner, 30); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), amount: 100 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + owner: owner.clone(), + spender: spender.clone(), + amount: 30, + live_until_ledger: 1000, + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Burn { from: owner.clone(), amount: 30 }.to_xdr(&e, &address) + ); }); } diff --git a/packages/tokens/src/fungible/test.rs b/packages/tokens/src/fungible/test.rs index 27678a85e..722fda674 100644 --- a/packages/tokens/src/fungible/test.rs +++ b/packages/tokens/src/fungible/test.rs @@ -6,12 +6,12 @@ use soroban_sdk::{ storage::{Instance, Persistent}, Address as _, Events, Ledger, MuxedAddress as _, }, - Address, Env, FromVal, IntoVal, Map, MuxedAddress, String, Symbol, TryFromVal, Val, + Address, Env, Event, FromVal, IntoVal, Map, MuxedAddress, String, Symbol, TryFromVal, Val, }; -use stellar_event_assertion::EventAssertion; use crate::fungible::{ - Base, FungibleStorageKey, BALANCE_EXTEND_AMOUNT, INSTANCE_EXTEND_AMOUNT, INSTANCE_TTL_THRESHOLD, + Approve, Base, FungibleStorageKey, Mint, MuxedTransfer, Transfer, BALANCE_EXTEND_AMOUNT, + INSTANCE_EXTEND_AMOUNT, INSTANCE_TTL_THRESHOLD, }; #[contract] @@ -70,9 +70,18 @@ fn approve_with_event() { let allowance_val = Base::allowance(&e, &owner, &spender); assert_eq!(allowance_val, 50); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_fungible_approve(&owner, &spender, allowance_data.0, allowance_data.1); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &Approve { + owner: owner.clone(), + spender: spender.clone(), + amount: allowance_data.0, + live_until_ledger: allowance_data.1, + } + .to_xdr(&e, &address) + ); }); } @@ -242,10 +251,17 @@ fn transfer_works() { assert_eq!(Base::balance(&e, &from), 50); assert_eq!(Base::balance(&e, &recipient), 50); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_fungible_mint(&from, 100); - event_assert.assert_fungible_transfer(&from, &recipient, 50); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: from.clone(), amount: 100 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Transfer { from: from.clone(), to: recipient.clone(), amount: 50 } + .to_xdr(&e, &address) + ); }); } @@ -281,14 +297,21 @@ fn transfer_muxed_address_works() { assert_eq!(Base::balance(&e, &from), 50); assert_eq!(Base::balance(&e, &recipient.address()), 50); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_fungible_mint(&from, 100); - event_assert.assert_fungible_muxed_transfer( - &from, - &recipient.address(), - recipient.id(), - 50, + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: from.clone(), amount: 100 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &MuxedTransfer { + from: from.clone(), + to: recipient.address(), + to_muxed_id: recipient.id(), + amount: 50, + } + .to_xdr(&e, &address) ); }); } @@ -431,11 +454,27 @@ fn approve_and_transfer_from() { let updated_allowance = Base::allowance(&e, &owner, &spender); assert_eq!(updated_allowance, 20); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_fungible_mint(&owner, 100); - event_assert.assert_fungible_approve(&owner, &spender, 50, 1000); - event_assert.assert_fungible_transfer(&owner, &recipient, 30); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), amount: 100 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + owner: owner.clone(), + spender: spender.clone(), + amount: 50, + live_until_ledger: 1000, + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), amount: 30 } + .to_xdr(&e, &address) + ); }); } @@ -764,9 +803,12 @@ fn mint_works() { assert_eq!(Base::balance(&e, &account), 100); assert_eq!(Base::total_supply(&e), 100); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_fungible_mint(&account, 100); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: account.clone(), amount: 100 }.to_xdr(&e, &address) + ); }); } diff --git a/packages/tokens/src/non_fungible/extensions/burnable/test.rs b/packages/tokens/src/non_fungible/extensions/burnable/test.rs index 7f2c3c308..51c6f4255 100644 --- a/packages/tokens/src/non_fungible/extensions/burnable/test.rs +++ b/packages/tokens/src/non_fungible/extensions/burnable/test.rs @@ -1,9 +1,12 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, Address, Env}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + Address, Env, Event, +}; -use crate::non_fungible::Base; +use crate::non_fungible::{extensions::burnable::Burn, Approve, ApproveForAll, Base, Mint}; #[contract] struct MockContract; @@ -22,10 +25,16 @@ fn burn_works() { assert!(Base::balance(&e, &owner) == 0); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_non_fungible_burn(&owner, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Burn { from: owner.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -45,11 +54,26 @@ fn burn_from_with_approve_works() { assert!(Base::balance(&e, &owner) == 0); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_non_fungible_approve(&owner, &spender, token_id, 1000); - event_assert.assert_non_fungible_burn(&owner, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + approver: owner.clone(), + token_id, + approved: spender.clone(), + live_until_ledger: 1000, + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Burn { from: owner.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -70,11 +94,25 @@ fn burn_from_with_operator_works() { assert!(Base::balance(&e, &owner) == 0); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_approve_for_all(&owner, &operator, 1000); - event_assert.assert_non_fungible_burn(&owner, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &ApproveForAll { + owner: owner.clone(), + operator: operator.clone(), + live_until_ledger: 1000 + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Burn { from: owner.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -92,10 +130,16 @@ fn burn_from_with_owner_works() { assert!(Base::balance(&e, &owner) == 0); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_non_fungible_burn(&owner, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Burn { from: owner.clone(), token_id }.to_xdr(&e, &address) + ); }); } diff --git a/packages/tokens/src/non_fungible/extensions/consecutive/test.rs b/packages/tokens/src/non_fungible/extensions/consecutive/test.rs index 624749a15..2fda2445a 100644 --- a/packages/tokens/src/non_fungible/extensions/consecutive/test.rs +++ b/packages/tokens/src/non_fungible/extensions/consecutive/test.rs @@ -1,17 +1,23 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, vec, Address, Env, String, Vec}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + vec, Address, Env, Event, String, Vec, +}; use crate::non_fungible::{ - extensions::consecutive::{ - storage::{ - find_bit_in_bucket, find_bit_in_item, NFTConsecutiveStorageKey, IDS_IN_BUCKET, - IDS_IN_ITEM, MAX_TOKENS_IN_BATCH, + extensions::{ + burnable::Burn, + consecutive::{ + storage::{ + find_bit_in_bucket, find_bit_in_item, NFTConsecutiveStorageKey, IDS_IN_BUCKET, + IDS_IN_ITEM, MAX_TOKENS_IN_BATCH, + }, + Consecutive, ConsecutiveMint, }, - Consecutive, }, - sequential, Base, + sequential, Approve, Base, Transfer, }; #[contract] @@ -193,9 +199,13 @@ fn consecutive_batch_mint_works() { e.as_contract(&address, || { Consecutive::batch_mint(&e, &owner, amount); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_consecutive_mint(&owner, 0, 31_999); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &ConsecutiveMint { to: owner.clone(), from_token_id: 0, to_token_id: 31_999 } + .to_xdr(&e, &address) + ); assert_eq!(sequential::next_token_id(&e), amount); assert_eq!(Base::balance(&e, &owner), amount); @@ -313,10 +323,18 @@ fn consecutive_transfer_works() { .unwrap(); assert_eq!(_owner, owner); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_consecutive_mint(&owner, 0, 99); - event_assert.assert_non_fungible_transfer(&owner, &recipient, 50); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &ConsecutiveMint { to: owner.clone(), from_token_id: 0, to_token_id: 99 } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), token_id: 50 } + .to_xdr(&e, &address) + ); }); } @@ -333,9 +351,13 @@ fn consecutive_transfer_edge_works() { e.as_contract(&address, || { Consecutive::batch_mint(&e, &owner, amount); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_consecutive_mint(&owner, 0, 99); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &ConsecutiveMint { to: owner.clone(), from_token_id: 0, to_token_id: 99 } + .to_xdr(&e, &address) + ); assert_eq!(Consecutive::owner_of(&e, 0), owner); Consecutive::transfer(&e, &owner, &recipient, 0); @@ -373,11 +395,27 @@ fn consecutive_transfer_from_works() { assert_eq!(Consecutive::owner_of(&e, token_id + 1), owner); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_consecutive_mint(&owner, 0, 99); - event_assert.assert_non_fungible_approve(&owner, &spender, token_id, 100); - event_assert.assert_non_fungible_transfer(&owner, &recipient, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &ConsecutiveMint { to: owner.clone(), from_token_id: 0, to_token_id: 99 } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + approver: owner.clone(), + token_id, + approved: spender.clone(), + live_until_ledger: 100, + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -408,10 +446,17 @@ fn consecutive_burn_works() { .unwrap(); assert_eq!(_owner, owner); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_consecutive_mint(&owner, 0, 99); - event_assert.assert_non_fungible_burn(&owner, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &ConsecutiveMint { to: owner.clone(), from_token_id: 0, to_token_id: 99 } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Burn { from: owner.clone(), token_id }.to_xdr(&e, &address) + ); }); e.as_contract(&address, || { @@ -450,11 +495,27 @@ fn consecutive_burn_from_works() { assert!(burned); assert_eq!(Consecutive::owner_of(&e, token_id + 1), owner); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_consecutive_mint(&owner, 0, 99); - event_assert.assert_non_fungible_approve(&owner, &spender, token_id, 100); - event_assert.assert_non_fungible_burn(&owner, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &ConsecutiveMint { to: owner.clone(), from_token_id: 0, to_token_id: 99 } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + approver: owner.clone(), + token_id, + approved: spender.clone(), + live_until_ledger: 100, + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Burn { from: owner.clone(), token_id }.to_xdr(&e, &address) + ); }); } diff --git a/packages/tokens/src/non_fungible/extensions/enumerable/test.rs b/packages/tokens/src/non_fungible/extensions/enumerable/test.rs index 13f7915c3..f22e06459 100644 --- a/packages/tokens/src/non_fungible/extensions/enumerable/test.rs +++ b/packages/tokens/src/non_fungible/extensions/enumerable/test.rs @@ -1,9 +1,12 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, Address, Env}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + Address, Env, Event, +}; -use crate::non_fungible::{extensions::enumerable::Enumerable, Base, NFTStorageKey}; +use crate::non_fungible::{extensions::enumerable::Enumerable, Base, Mint, NFTStorageKey}; #[contract] struct MockContract; @@ -21,10 +24,16 @@ fn test_total_supply() { assert_eq!(Enumerable::total_supply(&e), 2); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_non_fungible_mint(&owner, token_id1); - event_assert.assert_non_fungible_mint(&owner, token_id2); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id: token_id1 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Mint { to: owner.clone(), token_id: token_id2 }.to_xdr(&e, &address) + ); }); } diff --git a/packages/tokens/src/non_fungible/test.rs b/packages/tokens/src/non_fungible/test.rs index 82dd65b89..c09800940 100644 --- a/packages/tokens/src/non_fungible/test.rs +++ b/packages/tokens/src/non_fungible/test.rs @@ -2,12 +2,11 @@ extern crate std; use soroban_sdk::{ contract, - testutils::{Address as _, Ledger as _}, - Address, Env, String, + testutils::{Address as _, Events, Ledger as _}, + Address, Env, Event, String, }; -use stellar_event_assertion::EventAssertion; -use crate::non_fungible::{Base, NFTStorageKey}; +use crate::non_fungible::{Approve, ApproveForAll, Base, Mint, NFTStorageKey, Transfer}; #[contract] struct MockContract; @@ -124,9 +123,17 @@ fn approve_for_all_works() { let is_approved = Base::is_approved_for_all(&e, &owner, &operator); assert!(is_approved); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_approve_for_all(&owner, &operator, 1000); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &ApproveForAll { + owner: owner.clone(), + operator: operator.clone(), + live_until_ledger: 1000 + } + .to_xdr(&e, &address) + ); }); } @@ -153,9 +160,17 @@ fn revoke_approve_for_all_works() { let is_approved = Base::is_approved_for_all(&e, &owner, &operator); assert!(!is_approved); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_approve_for_all(&owner, &operator, 0); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &ApproveForAll { + owner: owner.clone(), + operator: operator.clone(), + live_until_ledger: 0 + } + .to_xdr(&e, &address) + ); }); } @@ -176,9 +191,18 @@ fn approve_nft_works() { let approved_address = Base::get_approved(&e, token_id); assert_eq!(approved_address, Some(approved.clone())); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_non_fungible_approve(&owner, &approved, token_id, 1000); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &Approve { + approver: owner.clone(), + token_id, + approved: approved.clone(), + live_until_ledger: 1000, + } + .to_xdr(&e, &address) + ); }); } @@ -203,10 +227,27 @@ fn approve_with_operator_works() { let approved_address = Base::get_approved(&e, token_id); assert_eq!(approved_address, Some(approved.clone())); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_approve_for_all(&owner, &operator, 1000); - event_assert.assert_non_fungible_approve(&operator, &approved, token_id, 1000); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &ApproveForAll { + owner: owner.clone(), + operator: operator.clone(), + live_until_ledger: 1000 + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + approver: operator.clone(), + token_id, + approved: approved.clone(), + live_until_ledger: 1000, + } + .to_xdr(&e, &address) + ); }); } @@ -227,10 +268,16 @@ fn transfer_nft_works() { assert_eq!(Base::balance(&e, &recipient), 1); assert_eq!(Base::owner_of(&e, token_id), recipient); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_non_fungible_transfer(&owner, &recipient, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -256,11 +303,26 @@ fn transfer_from_nft_approved_works() { assert_eq!(Base::balance(&e, &recipient), 1); assert_eq!(Base::owner_of(&e, token_id), recipient); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_non_fungible_approve(&owner, &spender, token_id, 1000); - event_assert.assert_non_fungible_transfer(&owner, &recipient, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Approve { + approver: owner.clone(), + token_id, + approved: spender.clone(), + live_until_ledger: 1000, + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -286,11 +348,25 @@ fn transfer_from_nft_operator_works() { assert_eq!(Base::balance(&e, &recipient), 1); assert_eq!(Base::owner_of(&e, token_id), recipient); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(3); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_approve_for_all(&owner, &spender, 1000); - event_assert.assert_non_fungible_transfer(&owner, &recipient, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 3); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &ApproveForAll { + owner: owner.clone(), + operator: spender.clone(), + live_until_ledger: 1000 + } + .to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(2).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -312,10 +388,16 @@ fn transfer_from_nft_owner_works() { assert_eq!(Base::balance(&e, &recipient), 1); assert_eq!(Base::owner_of(&e, token_id), recipient); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_non_fungible_mint(&owner, token_id); - event_assert.assert_non_fungible_transfer(&owner, &recipient, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Transfer { from: owner.clone(), to: recipient.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -488,9 +570,12 @@ fn mint_works() { let token_id = Base::sequential_mint(&e, &account); assert_eq!(Base::balance(&e, &account), 1); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(1); - event_assert.assert_non_fungible_mint(&account, token_id); + let events = e.events().all(); + assert_eq!(events.events().len(), 1); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: account.clone(), token_id }.to_xdr(&e, &address) + ); }); } @@ -505,10 +590,16 @@ fn test_counter_works() { let token_id1 = Base::sequential_mint(&e, &owner); let token_id2 = Base::sequential_mint(&e, &owner); - let mut event_assert = EventAssertion::new(&e, address.clone()); - event_assert.assert_event_count(2); - event_assert.assert_non_fungible_mint(&owner, token_id1); - event_assert.assert_non_fungible_mint(&owner, token_id2); + let events = e.events().all(); + assert_eq!(events.events().len(), 2); + assert_eq!( + events.events().first().unwrap(), + &Mint { to: owner.clone(), token_id: token_id1 }.to_xdr(&e, &address) + ); + assert_eq!( + events.events().get(1).unwrap(), + &Mint { to: owner.clone(), token_id: token_id2 }.to_xdr(&e, &address) + ); }); } diff --git a/packages/tokens/src/rwa/compliance/modules/supply_limit/test.rs b/packages/tokens/src/rwa/compliance/modules/supply_limit/test.rs index f65644a55..bf4e53d04 100644 --- a/packages/tokens/src/rwa/compliance/modules/supply_limit/test.rs +++ b/packages/tokens/src/rwa/compliance/modules/supply_limit/test.rs @@ -1,7 +1,10 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, Address, Env}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + Address, Env, +}; use crate::rwa::compliance::modules::supply_limit::storage::{ get_supply_count, get_supply_limit, on_created, on_destroyed, set_supply_limit, @@ -54,7 +57,7 @@ fn on_created_increments_counter_and_emits_event() { assert_eq!(get_supply_count(&e, &token), 70); // SupplyLimitSet + two SupplyCountUpdated emissions. - EventAssertion::new(&e, module_id.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } diff --git a/packages/tokens/src/rwa/compliance/test.rs b/packages/tokens/src/rwa/compliance/test.rs index 787cf6dc3..5065d7072 100644 --- a/packages/tokens/src/rwa/compliance/test.rs +++ b/packages/tokens/src/rwa/compliance/test.rs @@ -1,7 +1,10 @@ extern crate std; -use soroban_sdk::{contract, contractimpl, testutils::Address as _, vec, Address, Env}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, contractimpl, + testutils::{Address as _, Events}, + vec, Address, Env, +}; use crate::rwa::{ compliance::{ @@ -44,7 +47,7 @@ fn add_module_to_works() { let modules = get_modules_for_hook(&e, ComplianceHook::Transferred); assert_eq!(modules.len(), 1); assert_eq!(modules.get(0).unwrap(), module); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -138,7 +141,7 @@ fn remove_module_from_works() { let modules = get_modules_for_hook(&e, ComplianceHook::Transferred); assert!(modules.is_empty()); // 1 ModuleAdded + 1 ModuleRemoved - EventAssertion::new(&e, address.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/tokens/src/rwa/extensions/doc_manager/test.rs b/packages/tokens/src/rwa/extensions/doc_manager/test.rs index 93526aee7..0d2f486a0 100644 --- a/packages/tokens/src/rwa/extensions/doc_manager/test.rs +++ b/packages/tokens/src/rwa/extensions/doc_manager/test.rs @@ -1,7 +1,6 @@ extern crate std; -use soroban_sdk::{contract, Bytes, BytesN, Env, String, Vec}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{contract, testutils::Events, Bytes, BytesN, Env, String, Vec}; use crate::rwa::extensions::doc_manager::{ storage::{ @@ -51,7 +50,7 @@ fn set_document_success() { assert_eq!(stored_doc.document_hash, hash); // Timestamp should be set (in test environment it may be 0) let _ = stored_doc.timestamp; - EventAssertion::new(&e, contract_id.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -115,7 +114,7 @@ fn remove_document_success() { remove_document(&e, &name); assert_eq!(get_document_count(&e), 0); // 1 DocumentUpdated + 1 DocumentRemoved - EventAssertion::new(&e, contract_id.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/tokens/src/rwa/identity_verification/claim_issuer/test.rs b/packages/tokens/src/rwa/identity_verification/claim_issuer/test.rs index 990f46694..e7b546451 100644 --- a/packages/tokens/src/rwa/identity_verification/claim_issuer/test.rs +++ b/packages/tokens/src/rwa/identity_verification/claim_issuer/test.rs @@ -13,10 +13,9 @@ use p256::{ }; use soroban_sdk::{ contract, contractimpl, - testutils::{Address as _, Ledger as _}, + testutils::{Address as _, Events, Ledger as _}, Address, Bytes, BytesN, Env, Map, Vec, }; -use stellar_event_assertion::EventAssertion; use crate::rwa::identity_verification::{ claim_issuer::{ @@ -509,7 +508,7 @@ fn set_and_check_claim_revocation() { set_claim_revoked(&e, &identity, claim_topic, &claim_data, true); assert!(is_claim_revoked(&e, &identity, claim_topic, &claim_data)); - EventAssertion::new(&e, contract_id.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -589,7 +588,7 @@ fn topic_specific_key_management() { remove_key(&e, &public_key, ®istry, 1, topic); assert!(!is_key_allowed_for_topic(&e, &public_key, 1, topic)); // 1 KeyAllowed + 1 KeyRemoved - EventAssertion::new(&e, contract_id.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } @@ -1164,7 +1163,7 @@ fn invalidate_claim_signatures_increments_nonce() { invalidate_claim_signatures(&e, &identity, claim_topic); assert_eq!(get_current_nonce_for(&e, &identity, claim_topic), 2); // 2 SignaturesInvalidated - EventAssertion::new(&e, contract_id.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/tokens/src/rwa/identity_verification/claim_topics_and_issuers/test.rs b/packages/tokens/src/rwa/identity_verification/claim_topics_and_issuers/test.rs index 6aa890a10..f46506b30 100644 --- a/packages/tokens/src/rwa/identity_verification/claim_topics_and_issuers/test.rs +++ b/packages/tokens/src/rwa/identity_verification/claim_topics_and_issuers/test.rs @@ -1,7 +1,10 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, Address, Env, Vec}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + Address, Env, Vec, +}; use crate::rwa::identity_verification::claim_topics_and_issuers::storage::{ add_claim_topic, add_trusted_issuer, get_claim_topic_issuers, get_claim_topics, @@ -31,7 +34,7 @@ fn add_claim_topic_works() { let topics = get_claim_topics(&e); assert_eq!(topics.len(), 1); assert!(topics.contains(1)); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -110,7 +113,7 @@ fn remove_claim_topic_works() { assert!(!topics.contains(1)); assert!(topics.contains(2)); // 2 ClaimTopicAdded + 1 ClaimTopicRemoved - EventAssertion::new(&e, address.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } @@ -242,7 +245,7 @@ fn add_trusted_issuer_works() { assert!(issuer_topics.contains(1)); assert!(issuer_topics.contains(2)); // 2 ClaimTopicAdded + 1 TrustedIssuerAdded - EventAssertion::new(&e, address.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } @@ -399,7 +402,7 @@ fn remove_trusted_issuer_works() { assert!(!issuer_topics.contains(&issuer1)); assert!(issuer_topics.contains(&issuer2)); // 1 ClaimTopicAdded + 2 TrustedIssuerAdded + 1 TrustedIssuerRemoved - EventAssertion::new(&e, address.clone()).assert_event_count(4); + assert_eq!(e.events().all().events().len(), 4); }); } @@ -560,7 +563,7 @@ fn update_issuer_claim_topics_works() { assert!(topic4_issuers.contains(&issuer)); // should be added // 5 ClaimTopicAdded + 1 TrustedIssuerAdded + 1 IssuerTopicsUpdated - EventAssertion::new(&e, address.clone()).assert_event_count(7); + assert_eq!(e.events().all().events().len(), 7); }); } diff --git a/packages/tokens/src/rwa/identity_verification/identity_claims/test.rs b/packages/tokens/src/rwa/identity_verification/identity_claims/test.rs index fc607c035..0477c13d6 100644 --- a/packages/tokens/src/rwa/identity_verification/identity_claims/test.rs +++ b/packages/tokens/src/rwa/identity_verification/identity_claims/test.rs @@ -1,7 +1,8 @@ extern crate std; -use soroban_sdk::{contract, symbol_short, Address, Bytes, BytesN, Env, String, Vec}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, symbol_short, testutils::Events, Address, Bytes, BytesN, Env, String, Vec, +}; use crate::rwa::identity_verification::identity_claims::storage::{ add_claim, get_claim, get_claim_ids_by_topic, remove_claim, remove_claim_from_topic_index, @@ -76,7 +77,7 @@ fn add_claim_success() { let claim_ids = get_claim_ids_by_topic(&e, topic); assert_eq!(claim_ids.len(), 1); assert_eq!(claim_ids.get(0).unwrap(), claim_id); - EventAssertion::new(&e, contract_id.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -130,7 +131,7 @@ fn update_existing_claim() { let claim_ids = get_claim_ids_by_topic(&e, topic); assert_eq!(claim_ids.len(), 1); // 1 ClaimAdded + 1 ClaimChanged - EventAssertion::new(&e, contract_id.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } @@ -227,7 +228,7 @@ fn claim_removal() { let claim_ids_after = get_claim_ids_by_topic(&e, topic); assert_eq!(claim_ids_after.len(), 0); // 1 ClaimAdded + 1 ClaimRemoved - EventAssertion::new(&e, contract_id.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } diff --git a/packages/tokens/src/rwa/identity_verification/identity_registry_storage/test.rs b/packages/tokens/src/rwa/identity_verification/identity_registry_storage/test.rs index 670f4dcc2..84e783b07 100644 --- a/packages/tokens/src/rwa/identity_verification/identity_registry_storage/test.rs +++ b/packages/tokens/src/rwa/identity_verification/identity_registry_storage/test.rs @@ -1,10 +1,10 @@ extern crate std; use soroban_sdk::{ - contract, testutils::Address as _, vec, Address, Env, FromVal, IntoVal, Map, String, Symbol, - Val, Vec, + contract, + testutils::{Address as _, Events}, + vec, Address, Env, FromVal, IntoVal, Map, String, Symbol, Val, Vec, }; -use stellar_event_assertion::EventAssertion; use crate::rwa::identity_verification::identity_registry_storage::{ storage::{ @@ -49,7 +49,7 @@ fn add_identity_success() { assert_eq!(profile.countries.len(), 1); assert_eq!(get_country_data(&e, &account, 0), country_data); // 1 IdentityStored + 1 CountryDataAdded - EventAssertion::new(&e, contract_id.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } @@ -109,7 +109,7 @@ fn modify_identity_success() { assert_eq!(stored_identity(&e, &account), new_identity); // 1 IdentityStored + 1 CountryDataAdded + 1 IdentityModified - EventAssertion::new(&e, contract_id.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } @@ -191,7 +191,7 @@ fn remove_identity_success() { remove_identity(&e, &account); // 1 IdentityStored + 1 CountryDataAdded (from add) + 1 IdentityUnstored + 1 // CountryDataRemoved (from remove) - EventAssertion::new(&e, contract_id.clone()).assert_event_count(4); + assert_eq!(e.events().all().events().len(), 4); stored_identity(&e, &account); }); @@ -239,7 +239,7 @@ fn add_country_data_entries_success() { assert_eq!(get_country_data(&e, &account, 1), country_data2); // 1 IdentityStored + 1 CountryDataAdded (from add_identity) + 1 // CountryDataAdded (from add_country_data_entries) - EventAssertion::new(&e, contract_id.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } @@ -273,7 +273,7 @@ fn modify_country_data_success() { assert_eq!(get_country_data(&e, &account, 0), modified_country_data); // 1 IdentityStored + 1 CountryDataAdded + 1 CountryDataModified - EventAssertion::new(&e, contract_id.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } @@ -340,7 +340,7 @@ fn delete_country_data_success() { assert_eq!(get_country_data(&e, &account, 0), country_data1); assert_eq!(get_country_data(&e, &account, 1), country_data3); // 1 IdentityStored + 3 CountryDataAdded + 1 CountryDataRemoved - EventAssertion::new(&e, contract_id.clone()).assert_event_count(5); + assert_eq!(e.events().all().events().len(), 5); }); } @@ -707,7 +707,7 @@ fn recover_identity_success() { assert_eq!(get_country_data(&e, &new_account, 0), country_data1); assert_eq!(get_country_data(&e, &new_account, 1), country_data2); // 1 IdentityStored + 2 CountryDataAdded + 1 IdentityRecovered - EventAssertion::new(&e, contract_id.clone()).assert_event_count(4); + assert_eq!(e.events().all().events().len(), 4); }); } diff --git a/packages/tokens/src/rwa/identity_verification/test.rs b/packages/tokens/src/rwa/identity_verification/test.rs index 9d65b7897..0bff4bef3 100644 --- a/packages/tokens/src/rwa/identity_verification/test.rs +++ b/packages/tokens/src/rwa/identity_verification/test.rs @@ -2,9 +2,9 @@ extern crate std; use soroban_sdk::{ contract, contracterror, contractimpl, contracttype, map, panic_with_error, symbol_short, - testutils::Address as _, vec, Address, Bytes, BytesN, Env, Map, Vec, + testutils::{Address as _, Events}, + vec, Address, Bytes, BytesN, Env, Map, Vec, }; -use stellar_event_assertion::EventAssertion; use crate::rwa::identity_verification::{ claim_issuer::ClaimIssuer, @@ -129,7 +129,7 @@ fn set_and_get_claim_topics_and_issuers() { set_claim_topics_and_issuers(&e, &claim_topics_and_issuers_contract); assert_eq!(claim_topics_and_issuers(&e), claim_topics_and_issuers_contract); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -154,7 +154,7 @@ fn set_and_get_identity_registry_storage() { set_identity_registry_storage(&e, &identity_registry_contract); assert_eq!(identity_registry_storage(&e), identity_registry_contract); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } diff --git a/packages/tokens/src/rwa/test.rs b/packages/tokens/src/rwa/test.rs index 15f91081e..b58e7c6c7 100644 --- a/packages/tokens/src/rwa/test.rs +++ b/packages/tokens/src/rwa/test.rs @@ -1,11 +1,11 @@ extern crate std; use soroban_sdk::{ - contract, contractimpl, panic_with_error, symbol_short, testutils::Address as _, Address, Env, - String, + contract, contractimpl, panic_with_error, symbol_short, + testutils::{Address as _, Events}, + Address, Env, String, }; use stellar_contract_utils::pausable; -use stellar_event_assertion::EventAssertion; use crate::{ fungible::ContractOverrides, @@ -128,7 +128,7 @@ fn set_and_get_onchain_id() { let onchain_id = Address::generate(&e); RWA::set_onchain_id(&e, &onchain_id); assert_eq!(RWA::onchain_id(&e), onchain_id); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -152,7 +152,7 @@ fn set_and_get_compliance() { let compliance = Address::generate(&e); RWA::set_compliance(&e, &compliance); assert_eq!(RWA::compliance(&e), compliance); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -176,7 +176,7 @@ fn set_and_get_identity_verifier() { let identity_verifier = Address::generate(&e); RWA::set_identity_verifier(&e, &identity_verifier); assert_eq!(RWA::identity_verifier(&e), identity_verifier); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -204,7 +204,7 @@ fn mint_tokens() { assert_eq!(RWA::balance(&e, &to), 100); assert_eq!(RWA::total_supply(&e), 100); // 1 IdentityVerifierSet + 1 ComplianceSet + 1 Minted - EventAssertion::new(&e, address.clone()).assert_event_count(3); + assert_eq!(e.events().all().events().len(), 3); }); } @@ -310,7 +310,7 @@ fn burn_tokens() { assert_eq!(RWA::balance(&e, &account), 70); assert_eq!(RWA::total_supply(&e), 70); // 1 IdentityVerifierSet + 1 ComplianceSet + 1 Minted + 1 Burned - EventAssertion::new(&e, address.clone()).assert_event_count(4); + assert_eq!(e.events().all().events().len(), 4); }); } @@ -363,7 +363,7 @@ fn address_freezing() { RWA::set_address_frozen(&e, &user, false); assert!(!RWA::is_frozen(&e, &user)); // 1 AddressFrozen (true) + 1 AddressFrozen (false) - EventAssertion::new(&e, address.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); } @@ -390,7 +390,7 @@ fn partial_token_freezing() { assert_eq!(RWA::get_frozen_tokens(&e, &user), 20); // 1 IdentityVerifierSet + 1 ComplianceSet + 1 Minted + 1 TokensFrozen + 1 // TokensUnfrozen - EventAssertion::new(&e, address.clone()).assert_event_count(5); + assert_eq!(e.events().all().events().len(), 5); }); } @@ -454,7 +454,7 @@ fn recover_balance() { assert_eq!(RWA::balance(&e, &new_account), 100); // 1 IdentityVerifierSet + 1 ComplianceSet + 1 Minted + 1 Transfer (forced) + 1 // RecoverySuccess - EventAssertion::new(&e, address.clone()).assert_event_count(5); + assert_eq!(e.events().all().events().len(), 5); }); } diff --git a/packages/tokens/src/rwa/utils/token_binder/test.rs b/packages/tokens/src/rwa/utils/token_binder/test.rs index 20ed76e81..e302a909c 100644 --- a/packages/tokens/src/rwa/utils/token_binder/test.rs +++ b/packages/tokens/src/rwa/utils/token_binder/test.rs @@ -1,7 +1,10 @@ extern crate std; -use soroban_sdk::{contract, testutils::Address as _, Address, Env, Vec}; -use stellar_event_assertion::EventAssertion; +use soroban_sdk::{ + contract, + testutils::{Address as _, Events}, + Address, Env, Vec, +}; use crate::rwa::utils::token_binder::{ storage::{ @@ -59,7 +62,7 @@ fn bind_tokens_fits_current_bucket() { assert_eq!(get_token_by_index(&e, i), batch.get(i).unwrap()); } // one TokenBound per token - EventAssertion::new(&e, address.clone()).assert_event_count(10); + assert_eq!(e.events().all().events().len(), 10); linked_tokens(&e) }); @@ -137,7 +140,7 @@ fn bind_single_token() { assert!(is_token_bound(&e, &token)); assert_eq!(get_token_by_index(&e, 0), token); assert_eq!(get_token_index(&e, &token), 0); - EventAssertion::new(&e, address.clone()).assert_event_count(1); + assert_eq!(e.events().all().events().len(), 1); }); } @@ -196,7 +199,7 @@ fn unbind_single_token() { assert_eq!(linked_token_count(&e), 0); assert!(!is_token_bound(&e, &token)); // 1 TokenBound + 1 TokenUnbound - EventAssertion::new(&e, address.clone()).assert_event_count(2); + assert_eq!(e.events().all().events().len(), 2); }); }