Refactor events for pallet-revive and multiple ABI support (#2580)

* primitives: Implement Solidity ABI topic encoding

* tests: Event topic encoding

* primitives: Add `SolEncode::encode_topic`

* primitives: Solidity params encoding optimizations, docs and ergonomics

* primitives: Fix `PhantomData` decoding

* primitives: Add `AbiEncodeWith::encode_topic` and `AbiEncodeWith::encode_with`

* env: Refactor on-chain Solidity bytes encoding utilities

* env: Refactor events abstractions and utilities for `pallet-revive` and multiple ABI support

* tests: Update `Event` and `EventMetadata` macro tests

* tests: Update `TopicBuilder` tests

* doc: Update `Event` docs

* tests: Update events UI tests

* tests: Add events UI tests

* tests: Update events integration test

* Update changelog

* chore: Add `TODO` for removing `Environment::MAX_EVENT_TOPICS`

* chore: Fix linting UI test

* linting: Fix `primitive_topic` lint

* chore: Appease clippy in CI

* env: Emit events in both ABIs in "all" ABI mode

* tests: Add "all" ABI integration test for events

* macro: Add Solidity signature topic by ref

* doc: Update `Event` doc

* chore: Appease clippy in CI

* chore: Remove unused `ScopedBuffer::append_encoded`

* optimization: Ensure compile-time computation of selector when calling Blake2x256 precompile

Author: davidsemakula

CHANGELOG.md

@@ -37,6 +37,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Solidity ABI compatibility metadata improvements - [#2511](https://github.com/use-ink/ink/pull/2511)
 - Share intermediate build artifacts across all contract builds in e2e tests - [#2531](https://github.com/use-ink/ink/pull/2531)
 - Refactor Solidity bytes wrapper(s) - [#2569](https://github.com/use-ink/ink/pull/2569)
+- Refactor events for `pallet-revive` and multiple ABI support - [#2580](https://github.com/use-ink/ink/pull/2580)
 
 ### Fixed
 - Update metadata version to version 6 ‒ [#2507](https://github.com/use-ink/ink/pull/2507)

crates/engine/src/ext.rs

@@ -123,29 +123,9 @@ impl Engine {
     }
 
     /// Deposits an event identified by the supplied topics and data.
-    #[allow(clippy::arithmetic_side_effects)] // todo
-    pub fn deposit_event(&mut self, topics: &[u8], data: &[u8]) {
-        // The first byte contains the number of topics in the slice
-        let topics_count: scale::Compact<u32> = scale::Decode::decode(&mut &topics[0..1])
-            .unwrap_or_else(|err| panic!("decoding number of topics failed: {err}"));
-        let topics_count = topics_count.0 as usize;
-
-        let topics_vec = if topics_count > 0 {
-            // The rest of the slice contains the topics
-            let topics = &topics[1..];
-            let bytes_per_topic = topics.len() / topics_count;
-            let topics_vec: Vec<Vec<u8>> = topics
-                .chunks(bytes_per_topic)
-                .map(|chunk| chunk.to_vec())
-                .collect();
-            assert_eq!(topics_count, topics_vec.len());
-            topics_vec
-        } else {
-            Vec::new()
-        };
-
+    pub fn deposit_event(&mut self, topics: &[[u8; 32]], data: &[u8]) {
         self.debug_info.record_event(EmittedEvent {
-            topics: topics_vec,
+            topics: topics.to_vec(),
             data: data.to_vec(),
         });
     }

crates/engine/src/test_api.rs

@@ -33,7 +33,7 @@ use std::collections::HashMap;
 #[derive(Debug, Clone)]
 pub struct EmittedEvent {
     /// Recorded topics of the emitted event.
-    pub topics: Vec<Vec<u8>>,
+    pub topics: Vec<[u8; 32]>,
     /// Recorded encoding of the emitted event.
     pub data: Vec<u8>,
 }

crates/engine/src/tests.rs

@@ -129,18 +129,19 @@ fn transfer() {
 fn events() {
     // given
     let mut engine = Engine::new();
-    let topics_count: scale::Compact<u32> = scale::Compact(2u32);
-    let mut enc_topics_count = scale::Encode::encode(&topics_count);
-    let topic1 = vec![12u8, 13];
-    let topic2 = vec![14u8, 15];
+    let topic1 = [
+        12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+    ];
+    let topic2 = [
+        14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+    ];
     let data = &vec![21, 22, 23];
 
     // when
-    let mut enc_topics_info: Vec<u8> = Vec::new();
-    enc_topics_info.append(&mut enc_topics_count);
-    enc_topics_info.append(&mut topic1.clone());
-    enc_topics_info.append(&mut topic2.clone());
-    engine.deposit_event(&enc_topics_info, data);
+    let enc_topics = vec![topic1, topic2];
+    engine.deposit_event(&enc_topics, data);
 
     // then
     let mut events = engine.get_emitted_events();

crates/env/src/api.rs

@@ -46,7 +46,10 @@ use crate::{
         EnvInstance,
         OnInstance,
     },
-    event::Event,
+    event::{
+        Event,
+        TopicEncoder,
+    },
     hash::{
         CryptoHash,
         HashOutput,
@@ -180,13 +183,14 @@ where
 }
 
 /// Emits an event with the given event data.
-pub fn emit_event<E, Evt>(event: Evt)
+pub fn emit_event<E, Evt, Abi>(event: &Evt)
 where
     E: Environment,
-    Evt: Event,
+    Evt: Event<Abi>,
+    Abi: TopicEncoder,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        TypedEnvBackend::emit_event::<E, Evt>(instance, event)
+        TypedEnvBackend::emit_event::<E, Evt, Abi>(instance, event)
     })
 }
 

crates/env/src/backend.rs

@@ -37,7 +37,10 @@ use crate::{
         CallParams,
         DelegateCall,
     },
-    event::Event,
+    event::{
+        Event,
+        TopicEncoder,
+    },
     hash::{
         CryptoHash,
         HashOutput,
@@ -319,10 +322,11 @@ pub trait TypedEnvBackend: EnvBackend {
     /// # Note
     ///
     /// For more details visit: [`emit_event`][`crate::emit_event`]
-    fn emit_event<E, Evt>(&mut self, event: Evt)
+    fn emit_event<E, Evt, Abi>(&mut self, event: &Evt)
     where
         E: Environment,
-        Evt: Event;
+        Evt: Event<Abi>,
+        Abi: TopicEncoder;
 
     /// Invokes a contract message and returns its result.
     ///

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

@@ -16,7 +16,11 @@ use ink_engine::ext::Engine;
 #[cfg(feature = "unstable-hostfn")]
 use ink_primitives::types::AccountIdMapper;
 use ink_primitives::{
-    abi::AbiEncodeWith,
+    abi::{
+        AbiEncodeWith,
+        Ink,
+        Sol,
+    },
     types::Environment,
     Address,
     SolEncode,
@@ -47,6 +51,7 @@ use crate::{
     },
     event::{
         Event,
+        TopicEncoder,
         TopicsBuilderBackend,
     },
     hash::{
@@ -56,7 +61,6 @@ use crate::{
         Keccak256,
         Sha2x256,
     },
-    Clear,
     DecodeDispatch,
     DispatchError,
     EnvBackend,
@@ -247,46 +251,68 @@ impl CryptoHash for Keccak256 {
 
 #[derive(Default)]
 pub struct TopicsBuilder {
-    pub topics: Vec<Vec<u8>>,
+    pub topics: Vec<[u8; 32]>,
 }
 
-impl<E> TopicsBuilderBackend<E> for TopicsBuilder
+impl<E, Abi> TopicsBuilderBackend<E, Abi> for TopicsBuilder
 where
     E: Environment,
+    Abi: TopicEncoder,
 {
-    type Output = Vec<u8>;
+    type Output = Vec<[u8; 32]>;
 
     fn push_topic<T>(&mut self, topic_value: &T)
     where
-        T: scale::Encode,
+        T: AbiEncodeWith<Abi>,
     {
-        // todo
-        let encoded = topic_value.encode();
-        let len_encoded = encoded.len();
-        let mut result = <E as Environment>::Hash::CLEAR_HASH;
-        let len_result = result.as_ref().len();
-        if len_encoded <= len_result {
-            result.as_mut()[..len_encoded].copy_from_slice(&encoded[..]);
-        } else {
-            let mut hash_output = <Blake2x256 as HashOutput>::Type::default();
-            <Blake2x256 as CryptoHash>::hash(&encoded[..], &mut hash_output);
-            let copy_len = core::cmp::min(hash_output.len(), len_result);
-            result.as_mut()[0..copy_len].copy_from_slice(&hash_output[0..copy_len]);
-        }
-        let off_hash = result.as_ref();
-        let off_hash = off_hash.to_vec();
-        self.topics.push(off_hash);
+        let output = <Abi as TopicEncoder>::encode_topic(topic_value);
+        self.topics.push(output);
     }
 
     fn output(self) -> Self::Output {
-        let mut all: Vec<u8> = Vec::new();
+        self.topics
+    }
+}
 
-        let topics_len_compact = &scale::Compact(self.topics.len() as u32);
-        let topics_encoded = &scale::Encode::encode(&topics_len_compact)[..];
-        all.append(&mut topics_encoded.to_vec());
+impl TopicEncoder for Ink {
+    const REQUIRES_BUFFER: bool = false;
 
-        self.topics.into_iter().for_each(|mut v| all.append(&mut v));
-        all
+    fn encode_topic<T>(value: &T) -> [u8; 32]
+    where
+        T: AbiEncodeWith<Self>,
+    {
+        value.encode_topic(<Blake2x256 as CryptoHash>::hash)
+    }
+
+    fn encode_topic_with_hash_buffer<T>(
+        _value: &T,
+        _output: &mut [u8; 32],
+        _buffer: &mut [u8],
+    ) where
+        T: AbiEncodeWith<Self>,
+    {
+        unreachable!("not required, `encode_topic` has been implemented.");
+    }
+}
+
+impl TopicEncoder for Sol {
+    const REQUIRES_BUFFER: bool = false;
+
+    fn encode_topic<T>(value: &T) -> [u8; 32]
+    where
+        T: AbiEncodeWith<Self>,
+    {
+        value.encode_topic(<Keccak256 as CryptoHash>::hash)
+    }
+
+    fn encode_topic_with_hash_buffer<T>(
+        _value: &T,
+        _output: &mut [u8; 32],
+        _buffer: &mut [u8],
+    ) where
+        T: AbiEncodeWith<Self>,
+    {
+        unreachable!("not required, `encode_topic` has been implemented.");
     }
 }
 
@@ -607,15 +633,17 @@ impl TypedEnvBackend for EnvInstance {
             })
     }
 
-    fn emit_event<E, Evt>(&mut self, event: Evt)
+    fn emit_event<E, Evt, Abi>(&mut self, event: &Evt)
     where
         E: Environment,
-        Evt: Event,
+        Evt: Event<Abi>,
+        Abi: TopicEncoder,
     {
         let builder = TopicsBuilder::default();
         let enc_topics = event.topics::<E, _>(builder.into());
-        let enc_data = &scale::Encode::encode(&event)[..];
-        self.engine.deposit_event(&enc_topics[..], enc_data);
+        let enc_data = event.encode_data();
+        self.engine
+            .deposit_event(&enc_topics[..], enc_data.as_slice());
     }
 
     fn invoke_contract<E, Args, R, Abi>(

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

@@ -41,7 +41,7 @@ use ink_primitives::{
 #[derive(Clone)]
 pub struct EmittedEvent {
     /// Recorded topics of the emitted event.
-    pub topics: Vec<Vec<u8>>,
+    pub topics: Vec<[u8; 32]>,
     /// Recorded encoding of the emitted event.
     pub data: Vec<u8>,
 }

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

@@ -39,13 +39,13 @@ fn topics_builder() -> Result<()> {
         // then
         assert_eq!(builder.topics.len(), 2);
 
-        let topics_len_compact = &scale::Compact(2u32);
-        let topics_len_encoded = scale::Encode::encode(&topics_len_compact);
         let output = TopicsBuilderBackend::<crate::DefaultEnvironment>::output(builder);
         #[rustfmt::skip]
-        let expected = vec![topics_len_encoded[0], 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        let expected = vec![
+            [13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        ];
         assert_eq!(output, expected);
-
         Ok(())
     })
 }

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

@@ -202,23 +202,18 @@ impl<'a> ScopedBuffer<'a> {
         self.take(encode_len)
     }
 
-    /// Appends the encoding of `value` to the scoped buffer.
+    /// Appends the given bytes to the scoped buffer.
     ///
     /// Does not return the buffer immediately so that other values can be appended
     /// afterwards. The [`take_appended`] method shall be used to return the buffer
     /// that includes all appended encodings as a single buffer.
     #[inline(always)]
-    pub fn append_encoded<T>(&mut self, value: &T)
-    where
-        T: scale::Encode,
-    {
+    pub fn append_bytes(&mut self, bytes: &[u8]) {
         let offset = self.offset;
-        let buffer = core::mem::take(&mut self.buffer);
-        let mut encode_scope = EncodeScope::from(&mut buffer[offset..]);
-        scale::Encode::encode_to(&value, &mut encode_scope);
-        let encode_len = encode_scope.len();
-        self.offset = self.offset.checked_add(encode_len).unwrap();
-        let _ = core::mem::replace(&mut self.buffer, buffer);
+        let len = bytes.len();
+        let end_offset = offset.checked_add(len).unwrap();
+        self.buffer[offset..end_offset].copy_from_slice(bytes);
+        self.offset = end_offset;
     }
 
     /// Returns the buffer containing all encodings appended via [`append_encoded`]