Events 2.0

.gitlab-ci.yml

@@ -272,6 +272,8 @@ test:
     - job:                         check-std
       artifacts:                   false
   variables:
+      # Fix for linking of `linkme` for `cargo test`: https://github.com/dtolnay/linkme/issues/49
+      RUSTFLAGS: "-Clink-arg=-z -Clink-arg=nostart-stop-gc"
       # Since we run the tests with `--all-features` this implies the feature
       # `ink-fuzz-tests` as well -- i.e. the fuzz tests are run.
       # There's no way to disable a single feature while enabling all features
@@ -372,6 +374,9 @@ examples-test:
   needs:
     - job:                         clippy-std
       artifacts:                   false
+  variables:
+    # Fix linking of `linkme`: https://github.com/dtolnay/linkme/issues/49
+    RUSTFLAGS: "-Clink-arg=-z -Clink-arg=nostart-stop-gc"
   script:
     - for example in integration-tests/*/; do
         if [ "$example" = "integration-tests/lang-err-integration-tests/" ]; then continue; fi;
@@ -401,6 +406,9 @@ examples-contract-build:
   stage:                           examples
   <<:                              *docker-env
   <<:                              *test-refs
+  variables:
+    # Fix for linking of `linkme` for `cargo contract build`: https://github.com/dtolnay/linkme/issues/49
+    RUSTFLAGS: "-Clink-arg=-z -Clink-arg=nostart-stop-gc"
   script:
     - rustup component add rust-src --toolchain stable
     - cargo contract -V

crates/e2e/src/client.rs

@@ -17,6 +17,11 @@ use super::{
         constructor_exec_input,
         CreateBuilderPartial,
     },
+    events::{
+        CodeStoredEvent,
+        ContractInstantiatedEvent,
+        EventWithTopics,
+    },
     log_error,
     log_info,
     sr25519,
@@ -49,18 +54,15 @@ use std::{
     path::PathBuf,
 };
 
+use crate::events;
 use subxt::{
     blocks::ExtrinsicEvents,
     config::ExtrinsicParams,
     events::EventDetails,
-    ext::{
-        scale_decode,
-        scale_encode,
-        scale_value::{
-            Composite,
-            Value,
-            ValueDef,
-        },
+    ext::scale_value::{
+        Composite,
+        Value,
+        ValueDef,
     },
     tx::PairSigner,
 };
@@ -80,54 +82,6 @@ pub type CallBuilderFinal<E, Args, RetType> = ink_env::call::CallBuilder<
     Set<ReturnType<RetType>>,
 >;
 
-/// A contract was successfully instantiated.
-#[derive(
-    Debug,
-    scale::Decode,
-    scale::Encode,
-    scale_decode::DecodeAsType,
-    scale_encode::EncodeAsType,
-)]
-#[decode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_decode")]
-#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
-struct ContractInstantiatedEvent<E: Environment> {
-    /// Account id of the deployer.
-    pub deployer: E::AccountId,
-    /// Account id where the contract was instantiated to.
-    pub contract: E::AccountId,
-}
-
-impl<E> subxt::events::StaticEvent for ContractInstantiatedEvent<E>
-where
-    E: Environment,
-{
-    const PALLET: &'static str = "Contracts";
-    const EVENT: &'static str = "Instantiated";
-}
-
-/// Code with the specified hash has been stored.
-#[derive(
-    Debug,
-    scale::Decode,
-    scale::Encode,
-    scale_decode::DecodeAsType,
-    scale_encode::EncodeAsType,
-)]
-#[decode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_decode")]
-#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
-struct CodeStoredEvent<E: Environment> {
-    /// Hash under which the contract code was stored.
-    pub code_hash: E::Hash,
-}
-
-impl<E> subxt::events::StaticEvent for CodeStoredEvent<E>
-where
-    E: Environment,
-{
-    const PALLET: &'static str = "Contracts";
-    const EVENT: &'static str = "CodeStored";
-}
-
 /// The `Client` takes care of communicating with the node.
 ///
 /// This node's RPC interface will be used for instantiating the contract
@@ -726,4 +680,25 @@ impl<E: Environment, V, C: subxt::Config> CallResult<E, V, ExtrinsicEvents<C>> {
             event.pallet_name() == pallet_name && event.variant_name() == variant_name
         })
     }
+
+    /// Returns all the `ContractEmitted` events emitted by the contract.
+    pub fn contract_emitted_events(
+        &self,
+    ) -> Result<Vec<EventWithTopics<events::ContractEmitted<E>>>, subxt::Error>
+    where
+        C::Hash: Into<sp_core::H256>,
+    {
+        let mut events_with_topics = Vec::new();
+        for event in self.events.iter() {
+            let event = event?;
+            if let Some(decoded_event) = event.as_event::<events::ContractEmitted<E>>()? {
+                let event_with_topics = EventWithTopics {
+                    event: decoded_event,
+                    topics: event.topics().iter().cloned().map(Into::into).collect(),
+                };
+                events_with_topics.push(event_with_topics);
+            }
+        }
+        Ok(events_with_topics)
+    }
 }

crates/e2e/src/events.rs

@@ -0,0 +1,102 @@
+// Copyright 2018-2022 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ink_env::Environment;
+#[cfg(feature = "std")]
+use std::fmt::Debug;
+
+use subxt::{
+    events::StaticEvent,
+    ext::{
+        scale_decode,
+        scale_encode,
+    },
+};
+
+/// A contract was successfully instantiated.
+#[derive(
+    Debug,
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+)]
+#[decode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+pub struct ContractInstantiatedEvent<E: Environment> {
+    /// Account id of the deployer.
+    pub deployer: E::AccountId,
+    /// Account id where the contract was instantiated to.
+    pub contract: E::AccountId,
+}
+
+impl<E> StaticEvent for ContractInstantiatedEvent<E>
+where
+    E: Environment,
+{
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "Instantiated";
+}
+
+/// Code with the specified hash has been stored.
+#[derive(
+    Debug,
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+)]
+#[decode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+pub struct CodeStoredEvent<E: Environment> {
+    /// Hash under which the contract code was stored.
+    pub code_hash: E::Hash,
+}
+
+impl<E> StaticEvent for CodeStoredEvent<E>
+where
+    E: Environment,
+{
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "CodeStored";
+}
+
+#[derive(
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+    Debug,
+)]
+#[decode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+/// A custom event emitted by the contract.
+pub struct ContractEmitted<E: Environment> {
+    pub contract: E::AccountId,
+    pub data: Vec<u8>,
+}
+
+impl<E> StaticEvent for ContractEmitted<E>
+where
+    E: Environment,
+{
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "ContractEmitted";
+}
+
+/// A decoded event with its associated topics.
+pub struct EventWithTopics<T> {
+    pub topics: Vec<sp_core::H256>,
+    pub event: T,
+}

crates/e2e/src/lib.rs

@@ -24,6 +24,7 @@ mod client;
 mod contract_results;
 mod default_accounts;
 mod error;
+pub mod events;
 mod node_proc;
 mod xts;
 

crates/env/src/api.rs

@@ -32,11 +32,11 @@ use crate::{
         EnvInstance,
         OnInstance,
     },
+    event::Event,
     hash::{
         CryptoHash,
         HashOutput,
     },
-    topics::Topics,
     types::Gas,
     Environment,
     Result,
@@ -175,13 +175,13 @@ where
 }
 
 /// Emits an event with the given event data.
-pub fn emit_event<E, Event>(event: Event)
+pub fn emit_event<E, Evt>(event: Evt)
 where
     E: Environment,
-    Event: Topics + scale::Encode,
+    Evt: Event,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        TypedEnvBackend::emit_event::<E, Event>(instance, event)
+        TypedEnvBackend::emit_event::<E, Evt>(instance, event)
     })
 }
 

crates/env/src/backend.rs

@@ -21,11 +21,11 @@ use crate::{
         DelegateCall,
         FromAccountId,
     },
+    event::Event,
     hash::{
         CryptoHash,
         HashOutput,
     },
-    topics::Topics,
     Environment,
     Result,
 };
@@ -405,10 +405,10 @@ pub trait TypedEnvBackend: EnvBackend {
     /// # Note
     ///
     /// For more details visit: [`emit_event`][`crate::emit_event`]
-    fn emit_event<E, Event>(&mut self, event: Event)
+    fn emit_event<E, Evt>(&mut self, event: Evt)
     where
         E: Environment,
-        Event: Topics + scale::Encode;
+        Evt: Event;
 
     /// Invokes a contract message and returns its result.
     ///

crates/env/src/engine/off_chain/impls.rs

@@ -22,6 +22,10 @@ use crate::{
         DelegateCall,
         FromAccountId,
     },
+    event::{
+        Event,
+        TopicsBuilderBackend,
+    },
     hash::{
         Blake2x128,
         Blake2x256,
@@ -30,10 +34,6 @@ use crate::{
         Keccak256,
         Sha2x256,
     },
-    topics::{
-        Topics,
-        TopicsBuilderBackend,
-    },
     Clear,
     EnvBackend,
     Environment,
@@ -150,10 +150,6 @@ where
         }
         let off_hash = result.as_ref();
         let off_hash = off_hash.to_vec();
-        debug_assert!(
-            !self.topics.contains(&off_hash),
-            "duplicate topic hash discovered!"
-        );
         self.topics.push(off_hash);
     }
 
@@ -422,10 +418,10 @@ impl TypedEnvBackend for EnvInstance {
             })
     }
 
-    fn emit_event<E, Event>(&mut self, event: Event)
+    fn emit_event<E, Evt>(&mut self, event: Evt)
     where
         E: Environment,
-        Event: Topics + scale::Encode,
+        Evt: Event,
     {
         let builder = TopicsBuilder::default();
         let enc_topics = event.topics::<E, _>(builder.into());

crates/env/src/engine/off_chain/tests.rs

@@ -14,7 +14,7 @@
 
 use crate::{
     engine::off_chain::impls::TopicsBuilder,
-    topics::TopicsBuilderBackend,
+    event::TopicsBuilderBackend,
     Result,
 };