Shared external event definitions

crates/e2e/macro/Cargo.toml

@@ -21,7 +21,7 @@ proc-macro = true
 [dependencies]
 ink_ir = { version = "4.2.0", path = "../../ink/ir" }
 cargo_metadata = "0.15.3"
-contract-build = "2.0.2"
+contract-build = { git = "https://github.com/paritytech/cargo-contract", branch = "aj/shared-events-metadata", package = "contract-build" }
 derive_more = "0.99.17"
 env_logger = "0.10.0"
 log = "0.4.17"

crates/env/src/api.rs

@@ -178,7 +178,7 @@ where
 pub fn emit_event<E, Event>(event: Event)
 where
     E: Environment,
-    Event: Topics + scale::Encode,
+    Event: Topics<Env = E> + scale::Encode,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
         TypedEnvBackend::emit_event::<E, Event>(instance, event)

crates/env/src/backend.rs

@@ -408,7 +408,7 @@ pub trait TypedEnvBackend: EnvBackend {
     fn emit_event<E, Event>(&mut self, event: Event)
     where
         E: Environment,
-        Event: Topics + scale::Encode;
+        Event: Topics<Env = E> + scale::Encode;
 
     /// Invokes a contract message and returns its result.
     ///

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

@@ -425,10 +425,10 @@ impl TypedEnvBackend for EnvInstance {
     fn emit_event<E, Event>(&mut self, event: Event)
     where
         E: Environment,
-        Event: Topics + scale::Encode,
+        Event: Topics<Env = E> + scale::Encode,
     {
         let builder = TopicsBuilder::default();
-        let enc_topics = event.topics::<E, _>(builder.into());
+        let enc_topics = event.topics(builder.into());
         let enc_data = &scale::Encode::encode(&event)[..];
         self.engine.deposit_event(&enc_topics[..], enc_data);
     }

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

@@ -395,10 +395,11 @@ impl TypedEnvBackend for EnvInstance {
     fn emit_event<E, Event>(&mut self, event: Event)
     where
         E: Environment,
-        Event: Topics + scale::Encode,
+        Event: Topics<Env = E> + scale::Encode,
     {
-        let (mut scope, enc_topics) =
-            event.topics::<E, _>(TopicsBuilder::from(self.scoped_buffer()).into());
+        let (mut scope, enc_topics) = event.topics(
+            TopicsBuilder::<<Event as Topics>::Env>::from(self.scoped_buffer()).into(),
+        );
         let enc_data = scope.take_encoded(&event);
         ext::deposit_event(enc_topics, enc_data);
     }

crates/env/src/topics.rs

@@ -81,12 +81,12 @@ where
     /// Initializes the topics builder and informs it about how many topics it must expect
     /// to serialize.
     ///
-    /// The number of expected topics is given implicitly by the `E` type parameter.
-    pub fn build<Event: Topics>(
+    /// The number of expected topics is given by the `TopicsAmount` type parameter.
+    pub fn build<TopicsAmount: EventTopicsAmount>(
         mut self,
-    ) -> TopicsBuilder<<Event as Topics>::RemainingTopics, E, B> {
+    ) -> TopicsBuilder<TopicsAmount, E, B> {
         self.backend
-            .expect(<<Event as Topics>::RemainingTopics as EventTopicsAmount>::AMOUNT);
+            .expect(<TopicsAmount as EventTopicsAmount>::AMOUNT);
         TopicsBuilder {
             backend: self.backend,
             state: Default::default(),
@@ -191,18 +191,16 @@ impl EventTopicsAmount for state::NoRemainingTopics {
 ///
 /// Normally this trait should be implemented automatically via the ink! codegen.
 pub trait Topics {
-    /// Type state indicating how many event topics are to be expected by the topics
-    /// builder.
-    type RemainingTopics: EventTopicsAmount;
+    /// The environment type.
+    type Env: Environment;
 
     /// Guides event topic serialization using the given topics builder.
-    fn topics<E, B>(
+    fn topics<B>(
         &self,
-        builder: TopicsBuilder<state::Uninit, E, B>,
-    ) -> <B as TopicsBuilderBackend<E>>::Output
+        builder: TopicsBuilder<state::Uninit, Self::Env, B>,
+    ) -> <B as TopicsBuilderBackend<Self::Env>>::Output
     where
-        E: Environment,
-        B: TopicsBuilderBackend<E>;
+        B: TopicsBuilderBackend<Self::Env>;
 }
 
 /// For each topic a hash is generated. This hash must be unique
@@ -237,3 +235,78 @@ where
         self.value.encode_to(dest);
     }
 }
+
+use core::marker::PhantomData;
+
+/// Guards that an ink! event definitions respects the topic limit.
+///
+/// # Usage
+///
+/// ```
+/// // #[ink(event)]
+/// pub struct ExampleEvent {}
+///
+/// /// The amount of the topics of the example event struct.
+/// const LEN_TOPICS: usize = 3;
+///
+/// /// The limit for the amount of topics per ink! event definition.
+/// const TOPICS_LIMIT: usize = 4;
+///
+/// impl ::ink::codegen::EventLenTopics for ExampleEvent {
+///     type LenTopics = ::ink::codegen::EventTopics<LEN_TOPICS>;
+/// }
+///
+/// // The below code only compiles successfully if the example ink! event
+/// // definitions respects the topic limitation: it must have an amount of
+/// // topics less than or equal to the topic limit.
+/// const _: () = ::ink::codegen::utils::consume_type::<
+///     ::ink::codegen::EventRespectsTopicLimit<ExampleEvent, TOPICS_LIMIT>,
+/// >();
+/// ```
+pub struct EventRespectsTopicLimit<Event, const LEN_MAX_TOPICS: usize>
+where
+    Event: EventLenTopics,
+    <Event as EventLenTopics>::LenTopics: RespectTopicLimit<LEN_MAX_TOPICS>,
+{
+    marker: PhantomData<fn() -> Event>,
+}
+
+/// Guards that an amount of event topics respects the event topic limit.
+///
+/// # Note
+///
+/// Implemented by `EventTopics<M>` if M is less or equal to N.
+/// Automatically implemented for up to 12 event topics.
+pub trait RespectTopicLimit<const N: usize> {}
+
+/// Represents an the amount of topics for an ink! event definition.
+pub struct EventTopics<const N: usize>;
+
+macro_rules! impl_is_smaller_or_equals {
+    ( $first:literal $( , $rest:literal )* $(,)? ) => {
+        impl RespectTopicLimit<$first> for EventTopics<$first> {}
+        $(
+            impl RespectTopicLimit<$rest> for EventTopics<$first> {}
+        )*
+
+        impl_is_smaller_or_equals! { $( $rest ),* }
+    };
+    ( ) => {};
+}
+impl_is_smaller_or_equals! {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
+}
+
+/// Stores the number of event topics of the ink! event definition.
+pub trait EventLenTopics {
+    /// Type denoting the number of event topics.
+    ///
+    /// # Note
+    ///
+    /// We use an associated type instead of an associated constant here
+    /// because Rust does not yet allow for generics in constant parameter
+    /// position which would be required in the `EventRespectsTopicLimit`
+    /// trait definition.
+    /// As soon as this is possible in Rust we might change this to a constant.
+    type LenTopics;
+}

crates/ink/codegen/src/generator/event_def.rs

@@ -0,0 +1,223 @@
+// 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 crate::GenerateCode;
+
+use derive_more::From;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{
+    quote,
+    quote_spanned,
+};
+
+/// Generates code for an event definition.
+#[derive(From)]
+pub struct EventDefinition<'a> {
+    event_def: &'a ir::InkEventDefinition,
+}
+
+impl GenerateCode for EventDefinition<'_> {
+    fn generate_code(&self) -> TokenStream2 {
+        let event_enum = self.generate_event_enum();
+        let event_info_impls = self.generate_event_info_impl();
+        let event_variant_info_impls = self.generate_event_variant_info_impls();
+        let event_metadata_impl = self.generate_event_metadata_impl();
+        let topics_impl = self.generate_topics_impl();
+        let topics_guard = self.generate_topics_guard();
+        quote! {
+            #event_enum
+            #event_info_impls
+            #event_variant_info_impls
+            #event_metadata_impl
+            #topics_impl
+            #topics_guard
+        }
+    }
+}
+
+impl<'a> EventDefinition<'a> {
+    fn generate_event_enum(&'a self) -> TokenStream2 {
+        let span = self.event_def.span();
+        let event_enum = &self.event_def.item;
+        quote_spanned!(span =>
+            #[derive(::scale::Encode, ::scale::Decode)]
+            #event_enum
+        )
+    }
+
+    fn generate_event_info_impl(&self) -> TokenStream2 {
+        let span = self.event_def.span();
+        let event_ident = self.event_def.ident();
+
+        quote_spanned!(span=>
+            impl ::ink::reflect::EventInfo for #event_ident {
+                const PATH: &'static str = ::core::concat!(
+                    ::core::module_path!(),
+                    "::",
+                    ::core::stringify!(#event_ident)
+                );
+            }
+        )
+    }
+
+    fn generate_event_variant_info_impls(&self) -> TokenStream2 {
+        let span = self.event_def.span();
+        let event_ident = self.event_def.ident();
+
+        let impls = self.event_def.variants().map(|ev| {
+            let event_variant_ident = ev.ident();
+            let signature_topic = ev.signature_topic_hex_lits(event_ident);
+            let index = ev.index();
+            quote_spanned!(span=>
+                impl ::ink::reflect::EventVariantInfo<#index> for #event_ident {
+                    const NAME: &'static str = ::core::stringify!(#event_variant_ident);
+                    const SIGNATURE_TOPIC: [u8; 32] = [ #( #signature_topic ),* ];
+                }
+            )
+        });
+        quote_spanned!(span=>
+            #(
+                #impls
+            )*
+        )
+    }
+
+    fn generate_event_metadata_impl(&self) -> TokenStream2 {
+        let event_metadata = super::metadata::EventMetadata::from(self.event_def);
+        event_metadata.generate_code()
+    }
+
+    /// Generate checks to guard against too many topics in event definitions.
+    fn generate_topics_guard(&self) -> TokenStream2 {
+        let span = self.event_def.span();
+        let event_ident = self.event_def.ident();
+        // todo: [AJ] check if event signature topic should be included here (it is now,
+        // wasn't before)
+        let len_topics = self.event_def.max_len_topics();
+        let max_len_topics = quote_spanned!(span=>
+            <<#event_ident as ::ink::env::Topics>::Env
+                as ::ink::env::Environment>::MAX_EVENT_TOPICS
+        );
+        quote_spanned!(span=>
+            impl ::ink::codegen::EventLenTopics for #event_ident {
+                type LenTopics = ::ink::codegen::EventTopics<#len_topics>;
+            }
+
+            const _: () = ::ink::codegen::utils::consume_type::<
+                ::ink::codegen::EventRespectsTopicLimit<
+                    #event_ident,
+                    { #max_len_topics },
+                >
+            >();
+        )
+    }
+
+    fn generate_topics_impl(&self) -> TokenStream2 {
+        let span = self.event_def.span();
+        let event_ident = self.event_def.ident();
+
+        let variant_match_arms = self
+            .event_def
+            .variants()
+            .map(|variant| {
+                let span = variant.span();
+                let variant_ident = variant.ident();
+                let (field_bindings, field_topics): (Vec<_>, Vec<_>) = variant.fields()
+                    .filter(|field| field.is_topic)
+                    .map(|field| {
+                        let field_type = field.ty();
+                        let field_ident = field.ident();
+                        let push_topic =
+                            quote_spanned!(span =>
+                                .push_topic::<::ink::env::topics::PrefixedValue<#field_type>>(
+                                    &::ink::env::topics::PrefixedValue {
+                                        // todo: figure out whether we even need to include a prefix here?
+                                        // Previously the prefix would be the full field path e.g.
+                                        // erc20::Event::Transfer::from + value.
+                                        // However the value on its own might be sufficient, albeit
+                                        // requiring combination with the signature topic and some
+                                        // metadata to determine whether a topic value belongs to a
+                                        // specific field of a given Event variant. The upside is that
+                                        // indexers can use the unhashed value for meaningful topics
+                                        // e.g. addresses < 32 bytes. If the prefix is included we
+                                        // will always require to hash the value so need any indexer
+                                        // would not be able to go from hash > address.
+                                        prefix: &[],
+                                        value: #field_ident,
+                                    }
+                                )
+                            );
+                        let binding = quote_spanned!(span=> ref #field_ident);
+                        (binding, push_topic)
+                    })
+                    .unzip();
+
+                let index = variant.index();
+                let event_signature_topic = match variant.anonymous() {
+                    true => None,
+                    false => {
+                        Some(quote_spanned!(span=>
+                            .push_topic::<::ink::env::topics::PrefixedValue<()>>(
+                                &::ink::env::topics::PrefixedValue {
+                                    prefix: &<#event_ident as ::ink::reflect::EventVariantInfo<#index>>::SIGNATURE_TOPIC,
+                                    value: &(),
+                                }
+                            )
+                        ))
+                    }
+                };
+
+                let remaining_topics_ty = match variant.len_topics() {
+                    0 => quote_spanned!(span=> ::ink::env::topics::state::NoRemainingTopics),
+                    n => {
+                        quote_spanned!(span=> [::ink::env::topics::state::HasRemainingTopics; #n])
+                    }
+                };
+
+                quote_spanned!(span=>
+                    Self::#variant_ident { #( #field_bindings, )* .. } => {
+                        builder
+                            .build::<#remaining_topics_ty>()
+                            #event_signature_topic
+                            #(
+                                #field_topics
+                            )*
+                            .finish()
+                    }
+                )
+            });
+
+        quote_spanned!(span =>
+            const _: () = {
+                impl ::ink::env::Topics for #event_ident {
+                    type Env = ::ink::env::DefaultEnvironment; // todo: configure environment?
+
+                    fn topics<B>(
+                        &self,
+                        builder: ::ink::env::topics::TopicsBuilder<::ink::env::topics::state::Uninit, Self::Env, B>,
+                    ) -> <B as ::ink::env::topics::TopicsBuilderBackend<Self::Env>>::Output
+                    where
+                        B: ::ink::env::topics::TopicsBuilderBackend<Self::Env>,
+                    {
+                        match self {
+                            #(
+                                #variant_match_arms
+                            )*
+                        }
+                    }
+                }
+            };
+        )
+    }
+}