refactor: move code from sandbox to e2e

Author: Daanvdplas

crates/e2e/src/assertions.rs

@@ -104,27 +104,74 @@ macro_rules! assert_noop {
 /// ```
 #[macro_export]
 macro_rules! assert_last_event {
-    ($result:expr, $expected_event:expr) => {{
-        // Extract the last contract event from the result
-        let events = ($result)
+    ($result:expr, $expected_event:expr) => {{ $crate::assert_last_event_internal($result, $expected_event) }};
+}
+
+use crate::CallResult;
+use ink_env::Environment;
+use scale::{
+    Decode,
+    Encode,
+};
+use subxt::{
+    blocks::ExtrinsicEvents,
+    config::HashFor,
+};
+
+/// A trait for types that can expose the last contract-emitted event for assertions.
+#[allow(dead_code)]
+pub trait ContractEventReader {
+    fn fetch_last_contract_event(self) -> Result<Vec<u8>, String>;
+}
+
+impl<'a, E, V, C, Abi> ContractEventReader
+    for &'a CallResult<E, V, ExtrinsicEvents<C>, Abi>
+where
+    E: Environment,
+    C: subxt::Config,
+    HashFor<C>: Into<sp_core::H256>,
+{
+    fn fetch_last_contract_event(self) -> Result<Vec<u8>, String> {
+        let events = self
             .contract_emitted_events()
-            .expect("Failed to get contract events");
+            .map_err(|err| format!("failed to get contract events: {err:?}"))?;
 
-        if events.is_empty() {
-            panic!("No events emitted, expected: {:?}", $expected_event);
-        }
+        let last_event = events
+            .last()
+            .ok_or_else(|| "no contract events were emitted".to_string())?;
 
-        let last_event = events.last().expect("No last event");
+        Ok(last_event.event.data.clone())
+    }
+}
 
-        // Compare the encoded event data
-        let expected_bytes = ::ink::scale::Encode::encode(&$expected_event);
-        let actual_bytes = &last_event.event.data;
+/// Shared implementation that decodes the last contract event and compares it against the
+/// expected value.
+#[allow(dead_code)]
+pub fn assert_last_event_internal<R, E>(reader: R, expected_event: E)
+where
+    R: ContractEventReader,
+    E: Decode + Encode + core::fmt::Debug,
+{
+    let last_event_data = reader
+        .fetch_last_contract_event()
+        .unwrap_or_else(|err| panic!("Contract event assertion failed: {err}"));
 
-        if &expected_bytes != actual_bytes {
-            panic!(
-                "Event mismatch!\nExpected (encoded): {:?}\nActual (encoded): {:?}",
-                expected_bytes, actual_bytes
-            );
-        }
-    }};
+    let expected_bytes = expected_event.encode();
+
+    if expected_bytes != last_event_data {
+        let decoded_event =
+            E::decode(&mut &last_event_data[..]).unwrap_or_else(|error| {
+                panic!(
+                    "failed to decode last contract event as {}: bytes={:?}, error={:?}",
+                    core::any::type_name::<E>(),
+                    last_event_data,
+                    error
+                );
+            });
+
+        panic!(
+            "event mismatch!\nExpected: {:?}\nActual: {:?}",
+            expected_event, decoded_event
+        );
+    }
 }

crates/e2e/src/conversions.rs

@@ -0,0 +1,37 @@
+use crate::sr25519::Keypair;
+use sp_core::crypto::AccountId32;
+
+/// Trait for types that can be converted into an `AccountId`.
+pub trait IntoAccountId<TargetAccountId> {
+    fn into_account_id(self) -> TargetAccountId;
+}
+
+impl IntoAccountId<AccountId32> for AccountId32 {
+    fn into_account_id(self) -> AccountId32 {
+        self
+    }
+}
+
+impl IntoAccountId<AccountId32> for &AccountId32 {
+    fn into_account_id(self) -> AccountId32 {
+        self.clone()
+    }
+}
+
+impl<AccountId> IntoAccountId<AccountId> for &ink_primitives::AccountId
+where
+    AccountId: From<[u8; 32]>,
+{
+    fn into_account_id(self) -> AccountId {
+        AccountId::from(*AsRef::<[u8; 32]>::as_ref(self))
+    }
+}
+
+impl<AccountId> IntoAccountId<AccountId> for &Keypair
+where
+    AccountId: From<[u8; 32]>,
+{
+    fn into_account_id(self) -> AccountId {
+        AccountId::from(self.public_key().0)
+    }
+}

crates/e2e/src/lib.rs

@@ -26,13 +26,18 @@ mod builders;
 mod client_utils;
 mod contract_build;
 mod contract_results;
+mod conversions;
 mod error;
 pub mod events;
 mod node_proc;
 mod subxt_client;
 mod xts;
 
 pub use crate::contract_build::build_root_and_contract_dependencies;
+pub use assertions::{
+    ContractEventReader,
+    assert_last_event_internal,
+};
 pub use backend::{
     BuilderClient,
     ChainBackend,
@@ -62,6 +67,7 @@ pub use contract_results::{
     InstantiationResult,
     UploadResult,
 };
+pub use conversions::IntoAccountId;
 pub use ink_e2e_macro::test;
 pub use ink_revive_types::evm::CallTrace;
 pub use node_proc::{

crates/e2e/src/subxt_client.rs

@@ -397,11 +397,14 @@ where
     ///
     /// # Arguments
     /// * `asset_id` - ID of the asset.
+    /// * `owner` - The account that created/administers the asset and signs the mint
+    ///   extrinsic.
     /// * `beneficiary` - The account to receive the minted tokens (Keypair or AccountId).
     /// * `amount` - The number of tokens to mint.
     pub async fn mint_into(
         &mut self,
         asset_id: &u32,
+        owner: &Keypair,
         beneficiary: &impl ToAccountBytes,
         amount: u128,
     ) -> Result<(), Error>
@@ -410,24 +413,21 @@ where
     {
         let beneficiary_bytes = beneficiary.to_account_bytes();
         let beneficiary_account_id: C::AccountId = C::AccountId::from(beneficiary_bytes);
-        self.mint_into_impl(*asset_id, beneficiary_account_id, amount)
+        self.mint_into_impl(*asset_id, owner, beneficiary_account_id, amount)
             .await
     }
 
     /// Internal implementation for minting tokens.
     async fn mint_into_impl(
         &mut self,
         asset_id: u32,
+        owner: &Keypair,
         beneficiary_account_id: C::AccountId,
         amount: u128,
     ) -> Result<(), Error> {
-        // Use the first account (alice) as signer for now - in practice, this would be
-        // the asset admin
-        let signer = crate::sr25519::dev::alice();
-
         let (tx_events, trace) = self
             .api
-            .assets_mint(&signer, asset_id, beneficiary_account_id, amount)
+            .assets_mint(owner, asset_id, beneficiary_account_id, amount)
             .await;
 
         for evt in tx_events.iter() {

crates/sandbox/src/client.rs

@@ -49,6 +49,7 @@ use ink_e2e::{
     CallBuilderFinal,
     CallDryRunResult,
     ChainBackend,
+    ContractEventReader,
     ContractExecResultFor,
     ContractResult,
     ContractsBackend,
@@ -271,6 +272,50 @@ where
     }
 }
 
+impl<AccountId, S: Sandbox> Client<AccountId, S>
+where
+    S::Runtime: pallet_revive::Config,
+    <S::Runtime as frame_system::Config>::RuntimeEvent:
+        TryInto<pallet_revive::Event<S::Runtime>>,
+{
+    pub fn contract_events(&mut self) -> Vec<Vec<u8>> {
+        self.sandbox
+            .events()
+            .iter()
+            .filter_map(|event_record| {
+                if let Ok(pallet_event) = &event_record.event.clone().try_into() {
+                    match pallet_event {
+                        pallet_revive::Event::<S::Runtime>::ContractEmitted {
+                            data,
+                            ..
+                        } => Some(data.clone()),
+                        _ => None,
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<Vec<u8>>>()
+    }
+
+    pub fn last_contract_event(&mut self) -> Option<Vec<u8>> {
+        self.contract_events().last().cloned()
+    }
+}
+
+impl<'a, AccountId, S> ContractEventReader for &'a mut Client<AccountId, S>
+where
+    S: Sandbox,
+    S::Runtime: pallet_revive::Config,
+    <S::Runtime as frame_system::Config>::RuntimeEvent:
+        TryInto<pallet_revive::Event<S::Runtime>>,
+{
+    fn fetch_last_contract_event(self) -> Result<Vec<u8>, String> {
+        self.last_contract_event()
+            .ok_or_else(|| "no contract events were emitted".to_string())
+    }
+}
+
 #[async_trait]
 impl<
     AccountId: Clone + Send + Sync + From<[u8; 32]> + AsRef<[u8; 32]>,
@@ -718,86 +763,6 @@ where
     }
 }
 
-impl<AccountId, S: Sandbox> Client<AccountId, S>
-where
-    S::Runtime: pallet_revive::Config,
-    <S::Runtime as frame_system::Config>::RuntimeEvent:
-        TryInto<pallet_revive::Event<S::Runtime>>,
-{
-    pub fn contract_events(&mut self) -> Vec<Vec<u8>>
-    where
-        S::Runtime: pallet_revive::Config,
-        <S::Runtime as frame_system::Config>::RuntimeEvent:
-            TryInto<pallet_revive::Event<S::Runtime>>,
-    {
-        self.sandbox
-            .events()
-            .iter()
-            .filter_map(|event_record| {
-                if let Ok(pallet_event) = &event_record.event.clone().try_into() {
-                    match pallet_event {
-                        pallet_revive::Event::<S::Runtime>::ContractEmitted {
-                            data,
-                            ..
-                        } => Some(data.clone()),
-                        _ => None,
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<Vec<u8>>>()
-    }
-
-    /// Returns the last contract event that was emitted, if any.
-    pub fn last_contract_event(&mut self) -> Option<Vec<u8>>
-    where
-        S::Runtime: pallet_revive::Config,
-        <S::Runtime as frame_system::Config>::RuntimeEvent:
-            TryInto<pallet_revive::Event<S::Runtime>>,
-    {
-        self.contract_events().last().cloned()
-    }
-}
-
-/// Helper function for the `assert_last_contract_event!` macro.
-///
-/// # Parameters:
-/// - `client` - The client for interacting with the sandbox.
-/// - `event` - The expected event.
-#[track_caller]
-pub fn assert_last_contract_event_inner<AccountId, S, E>(
-    client: &mut Client<AccountId, S>,
-    event: E,
-) where
-    S: Sandbox,
-    S::Runtime: pallet_revive::Config,
-    <S::Runtime as frame_system::Config>::RuntimeEvent:
-        TryInto<pallet_revive::Event<S::Runtime>>,
-    E: Decode + scale::Encode + core::fmt::Debug + std::cmp::PartialEq,
-{
-    let expected_event = event;
-    let last_event = client
-        .last_contract_event()
-        .unwrap_or_else(|| panic!("contract events expected but none were emitted yet"));
-
-    let decoded_event = E::decode(&mut &last_event[..]).unwrap_or_else(|error| {
-        panic!(
-            "failed to decode last contract event as {}: bytes={:?}, error={:?}",
-            core::any::type_name::<E>(),
-            last_event,
-            error
-        );
-    });
-
-    if decoded_event != expected_event {
-        panic!(
-            "expected contract event {:?} but found {:?}",
-            expected_event, decoded_event
-        );
-    }
-}
-
 impl<
     AccountId: Clone + Send + Sync + From<[u8; 32]> + AsRef<[u8; 32]>,
     Config: Sandbox,

crates/sandbox/src/lib.rs

@@ -71,6 +71,12 @@ pub use client::{
     preset,
 };
 pub use error::E2EError;
+pub use ink_e2e::{
+    IntoAccountId,
+    assert_last_event,
+    assert_noop,
+    assert_ok,
+};
 pub use ink_e2e_macro::test;
 
 /// Asserts that a contract call succeeded without reverting.
@@ -383,29 +389,3 @@ pub fn to_revive_storage_deposit<B>(
         }
     }
 }
-
-/// Trait for types that can be converted into a runtime AccountId.
-///
-/// This allows sandbox APIs to accept various account types without requiring manual
-/// conversion.
-pub trait IntoAccountId<AccountId> {
-    fn into_account_id(self) -> AccountId;
-}
-
-impl IntoAccountId<AccountId32> for &AccountId32 {
-    fn into_account_id(self) -> AccountId32 {
-        self.clone()
-    }
-}
-
-impl IntoAccountId<AccountId32> for &ink_primitives::AccountId {
-    fn into_account_id(self) -> AccountId32 {
-        AccountId32::from(*AsRef::<[u8; 32]>::as_ref(self))
-    }
-}
-
-impl IntoAccountId<AccountId32> for &ink_e2e::Keypair {
-    fn into_account_id(self) -> AccountId32 {
-        AccountId32::from(self.public_key().0)
-    }
-}