feat: #[event] macros codec selection (#1325)

Author: vobradovich

rs/client-gen-js/src/service_generator.rs

@@ -51,6 +51,7 @@ impl<'a> ServiceGenerator<'a> {
         let event_tokens = service
             .events
             .iter()
+            .filter(|event| has_scale_codec(&event.annotations))
             .map(|event| self.render_event(event, event.entry_id));
 
         let extend_tokens = service.extends.iter().map(|base| {

rs/client-gen-js/tests/generator.rs

@@ -71,6 +71,18 @@ fn codec_selection() {
         !generated.contains("ethabiQuery"),
         "expected ethabiQuery to be filtered out, got:\n{generated}"
     );
+    assert!(
+        generated.contains("subscribeToBothEventEvent"),
+        "expected subscribeToBothEventEvent to be present"
+    );
+    assert!(
+        generated.contains("subscribeToScaleOnlyEventEvent"),
+        "expected subscribeToScaleOnlyEventEvent to be present"
+    );
+    assert!(
+        !generated.contains("subscribeToEthabiOnlyEventEvent"),
+        "expected subscribeToEthabiOnlyEventEvent to be filtered out, got:\n{generated}"
+    );
 
     assert_snapshot!("codec_selection", generated);
 }

rs/client-gen-js/tests/idls/codec.idl

@@ -21,6 +21,19 @@ service CodecTest {
         @codec: ethabi
         EthabiQuery(p1: bool) -> bool;
     }
+    events {
+        /// Available through both codecs
+        @entry_id: 0
+        BothEvent(u32),
+        /// SCALE only
+        @entry_id: 1
+        @codec: scale
+        ScaleOnlyEvent(u32),
+        /// Ethabi only, should be excluded from JS event subscriptions
+        @entry_id: 2
+        @codec: ethabi
+        EthabiOnlyEvent(u32),
+    }
 }
 
 program CodecProgram {

rs/client-gen-js/tests/snapshots/generator__codec_selection.snap

@@ -3,8 +3,9 @@ source: rs/client-gen-js/tests/generator.rs
 expression: generated
 ---
 import {GearApi, HexString} from "@gear-js/api";
-import {QueryBuilderWithHeader, TransactionBuilderWithHeader, TypeResolver} from "sails-js";
+import {QueryBuilderWithHeader, TransactionBuilderWithHeader, TypeResolver, ZERO_ADDRESS} from "sails-js";
 import {InterfaceId, SailsMessageHeader} from "sails-js-parser-idl-v2";
+import {IStructField} from "sails-js-types";
 
 export class CodecProgram {
     private _typeResolver: TypeResolver;
@@ -42,7 +43,7 @@ export class CodecTest {
         return this._typeResolver.registry;
     }
     public get interfaceId(): InterfaceId {
-        return InterfaceId.from("0x577754119419635e");
+        return InterfaceId.from("0x3d3ab867eece8ee1");
     }
     /**
      * Available via both codecs (default)
@@ -90,4 +91,40 @@ export class CodecTest {
             this._programId,
         );
     }
+
+    /**
+     * Available through both codecs
+     */
+    public subscribeToBothEventEvent<T = number>(callback: (eventData: T) => void | Promise<void>): Promise<() => void> {
+        const interfaceIdu64 = this.interfaceId.asU64();
+        const eventFields = {"fields":[{"type":"u32"}]}.fields as IStructField[];
+        const typeStr = this._typeResolver.getStructDef(eventFields, {}, true);
+        return this._api.gearEvents.subscribeToGearEvent("UserMessageSent", ({ data: { message } }) => {
+            if (!message.source.eq(this._programId)) return;
+            if (!message.destination.eq(ZERO_ADDRESS)) return;
+
+            const { ok, header } = SailsMessageHeader.tryFromBytes(message.payload);
+            if (ok && header.interfaceId.asU64() === interfaceIdu64 && header.entryId === 0) {
+                callback(this.registry.createType(`([u8; 16], ${typeStr})`, message.payload)[1].toJSON() as T);
+            }
+        });
+    }
+
+    /**
+     * SCALE only
+     */
+    public subscribeToScaleOnlyEventEvent<T = number>(callback: (eventData: T) => void | Promise<void>): Promise<() => void> {
+        const interfaceIdu64 = this.interfaceId.asU64();
+        const eventFields = {"fields":[{"type":"u32"}]}.fields as IStructField[];
+        const typeStr = this._typeResolver.getStructDef(eventFields, {}, true);
+        return this._api.gearEvents.subscribeToGearEvent("UserMessageSent", ({ data: { message } }) => {
+            if (!message.source.eq(this._programId)) return;
+            if (!message.destination.eq(ZERO_ADDRESS)) return;
+
+            const { ok, header } = SailsMessageHeader.tryFromBytes(message.payload);
+            if (ok && header.interfaceId.asU64() === interfaceIdu64 && header.entryId === 1) {
+                callback(this.registry.createType(`([u8; 16], ${typeStr})`, message.payload)[1].toJSON() as T);
+            }
+        });
+    }
 }

rs/client-gen-v2/src/events_generator.rs

@@ -1,4 +1,5 @@
 use genco::prelude::*;
+use sails_idl_ast::codec::has_scale_codec;
 use sails_idl_parser_v2::{ast, visitor, visitor::Visitor};
 
 use crate::helpers::generate_doc_comments;
@@ -25,6 +26,15 @@ impl<'ast> EventsModuleGenerator<'ast> {
 
 impl<'ast> Visitor<'ast> for EventsModuleGenerator<'ast> {
     fn visit_service_unit(&mut self, service: &'ast ast::ServiceUnit) {
+        let scale_events = service
+            .events
+            .iter()
+            .filter(|event| has_scale_codec(&event.annotations))
+            .collect::<Vec<_>>();
+        if scale_events.is_empty() {
+            return;
+        }
+
         let events_name = &format!("{}Events", self.service_name);
 
         quote_in! { self.tokens =>
@@ -46,7 +56,7 @@ impl<'ast> Visitor<'ast> for EventsModuleGenerator<'ast> {
             impl $events_name {
                 pub fn entry_id(&self) -> u16 {
                     match self {
-                        $(for event in &service.events join ($['\r']) =>
+                        $(for event in &scale_events join ($['\r']) =>
                             Self::$(&event.name) { .. } => $(event.entry_id),
                         )
                     }
@@ -77,6 +87,10 @@ impl<'ast> Visitor<'ast> for EventsModuleGenerator<'ast> {
     }
 
     fn visit_service_event(&mut self, event: &'ast ast::ServiceEvent) {
+        if !has_scale_codec(&event.annotations) {
+            return;
+        }
+
         generate_doc_comments(&mut self.tokens, &event.docs);
 
         let variant_name = &event.name;

rs/client-gen-v2/tests/generator.rs

@@ -108,6 +108,19 @@ fn codec_selection() {
         !generated.contains("ethabi_query"),
         "expected ethabi_query to be filtered out"
     );
+
+    assert!(
+        generated.contains("BothEvent"),
+        "expected BothEvent to be present"
+    );
+    assert!(
+        generated.contains("ScaleOnlyEvent"),
+        "expected ScaleOnlyEvent to be present"
+    );
+    assert!(
+        !generated.contains("EthabiOnlyEvent"),
+        "expected EthabiOnlyEvent to be filtered out"
+    );
     insta::assert_snapshot!(generated);
 }
 

rs/client-gen-v2/tests/idls/codec.idl

@@ -21,6 +21,19 @@ service CodecTest {
         @codec: ethabi
         EthabiQuery(p1: bool) -> bool;
     }
+    events {
+        /// Available through both codecs
+        @entry_id: 0
+        BothEvent(u32),
+        /// SCALE only
+        @entry_id: 1
+        @codec: scale
+        ScaleOnlyEvent(u32),
+        /// Ethabi only, should be excluded from Rust client events
+        @entry_id: 2
+        @codec: ethabi
+        EthabiOnlyEvent(u32),
+    }
 }
 
 program CodecProgram {

rs/client-gen-v2/tests/snapshots/generator__codec_selection.snap

@@ -1,6 +1,6 @@
 ---
 source: rs/client-gen-v2/tests/generator.rs
-expression: gen_client(idl)
+expression: generated
 ---
 // Code generated by sails-client-gen-v2. DO NOT EDIT.
 #[cfg(feature = "with_mocks")]
@@ -66,7 +66,7 @@ pub mod codec_test {
 
     impl sails_rs::client::Identifiable for CodecTestImpl {
         const INTERFACE_ID: sails_rs::InterfaceId =
-            sails_rs::InterfaceId::from_bytes_8([87, 119, 84, 17, 148, 25, 99, 94]);
+            sails_rs::InterfaceId::from_bytes_8([61, 58, 184, 103, 238, 206, 142, 225]);
     }
 
     impl<E: sails_rs::client::GearEnv> CodecTest for sails_rs::client::Service<CodecTestImpl, E> {
@@ -95,6 +95,48 @@ pub mod codec_test {
         sails_rs::io_struct_impl!(ScaleOnly (p1: u32) -> u32, 1, <super::CodecTestImpl as sails_rs::client::Identifiable>::INTERFACE_ID);
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    pub mod events {
+        use super::*;
+        #[sails_rs::sails_type(crate = sails_rs)]
+        #[derive(PartialEq, Debug)]
+        pub enum CodecTestEvents {
+            /// Available through both codecs
+            #[codec(index = 0)]
+            BothEvent(u32),
+            /// SCALE only
+            #[codec(index = 1)]
+            ScaleOnlyEvent(u32),
+        }
+
+        impl CodecTestEvents {
+            pub fn entry_id(&self) -> u16 {
+                match self {
+                    Self::BothEvent { .. } => 0,
+                    Self::ScaleOnlyEvent { .. } => 1,
+                }
+            }
+        }
+
+        impl sails_rs::client::Event for CodecTestEvents {
+            fn decode_event(
+                route: &sails_rs::client::RouteIdx,
+                payload: impl AsRef<[u8]>,
+            ) -> Result<Self, sails_rs::scale_codec::Error> {
+                sails_rs::client::decode_event_v2::<Self>(route.0, payload)
+            }
+        }
+
+        impl sails_rs::client::Identifiable for CodecTestEvents {
+            const INTERFACE_ID: sails_rs::InterfaceId =
+                <CodecTestImpl as sails_rs::client::Identifiable>::INTERFACE_ID;
+        }
+
+        impl sails_rs::client::ServiceWithEvents for CodecTestImpl {
+            type Event = CodecTestEvents;
+        }
+    }
+
     #[cfg(feature = "with_mocks")]
     #[cfg(not(target_arch = "wasm32"))]
     pub mod mockall {

rs/ethexe/macros-tests/tests/eth_event.rs

@@ -58,3 +58,57 @@ fn eth_event_sails_rename() {
 
     insta::assert_snapshot!(result);
 }
+
+#[test]
+fn eth_event_scale_only() {
+    let attrs = quote! {
+        scale
+    };
+    let input = quote! {
+        pub enum Events {
+            MyEvent1(u128),
+            MyEvent2,
+        }
+    };
+    let result = event(attrs, input).to_string();
+    let result = prettyplease::unparse(&syn::parse_str(&result).unwrap());
+
+    insta::assert_snapshot!(result);
+}
+
+#[test]
+fn eth_event_ethabi_only() {
+    let attrs = quote! {
+        ethabi
+    };
+    let input = quote! {
+        pub enum Events {
+            MyEvent1 {
+                #[indexed]
+                sender: sails_rs::alloy_primitives::Address,
+                amount: sails_rs::alloy_primitives::U256,
+            },
+            MyEvent2,
+        }
+    };
+    let result = event(attrs, input).to_string();
+    let result = prettyplease::unparse(&syn::parse_str(&result).unwrap());
+
+    insta::assert_snapshot!(result);
+}
+
+#[test]
+fn eth_event_scale_and_ethabi() {
+    let attrs = quote! {
+        scale, ethabi
+    };
+    let input = quote! {
+        pub enum Events {
+            MyEvent1(u128),
+        }
+    };
+    let result = event(attrs, input).to_string();
+    let result = prettyplease::unparse(&syn::parse_str(&result).unwrap());
+
+    insta::assert_snapshot!(result);
+}

rs/ethexe/macros-tests/tests/snapshots/eth_event__eth_event_ethabi_only.snap

@@ -0,0 +1,71 @@
+---
+source: macros-tests/tests/eth_event.rs
+expression: result
+---
+pub enum Events {
+    #[annotate(codec = "ethabi")]
+    MyEvent1 {
+        #[annotate(indexed)]
+        sender: sails_rs::alloy_primitives::Address,
+        amount: sails_rs::alloy_primitives::U256,
+    },
+    #[annotate(codec = "ethabi")]
+    MyEvent2,
+}
+impl sails_rs::EthEvent for Events {
+    const SIGNATURES: &'static [sails_rs::gstd::EthEventExpo] = &[
+        (
+            "MyEvent1",
+            <<(
+                sails_rs::alloy_primitives::Address,
+                sails_rs::alloy_primitives::U256,
+            ) as sails_rs::alloy_sol_types::SolValue>::SolType as sails_rs::alloy_sol_types::SolType>::SOL_NAME,
+            sails_rs::keccak_const::Keccak256::new()
+                .update("MyEvent1".as_bytes())
+                .update(
+                    <<(
+                        sails_rs::alloy_primitives::Address,
+                        sails_rs::alloy_primitives::U256,
+                    ) as sails_rs::alloy_sol_types::SolValue>::SolType as sails_rs::alloy_sol_types::SolType>::SOL_NAME
+                        .as_bytes(),
+                )
+                .finalize(),
+        ),
+        (
+            "MyEvent2",
+            <<() as sails_rs::alloy_sol_types::SolValue>::SolType as sails_rs::alloy_sol_types::SolType>::SOL_NAME,
+            sails_rs::keccak_const::Keccak256::new()
+                .update("MyEvent2".as_bytes())
+                .update(
+                    <<() as sails_rs::alloy_sol_types::SolValue>::SolType as sails_rs::alloy_sol_types::SolType>::SOL_NAME
+                        .as_bytes(),
+                )
+                .finalize(),
+        ),
+    ];
+    #[allow(unused)]
+    fn topics(&self) -> sails_rs::Vec<sails_rs::alloy_primitives::B256> {
+        match self {
+            Events::MyEvent1 { sender, amount } => {
+                let mut topics = sails_rs::Vec::with_capacity(2usize);
+                let (_, _, hash) = Self::SIGNATURES[0usize];
+                topics.push(sails_rs::alloy_primitives::B256::new(hash));
+                topics.push(Self::topic_hash(sender));
+                topics
+            }
+            Events::MyEvent2 => {
+                let mut topics = sails_rs::Vec::with_capacity(1usize);
+                let (_, _, hash) = Self::SIGNATURES[1usize];
+                topics.push(sails_rs::alloy_primitives::B256::new(hash));
+                topics
+            }
+        }
+    }
+    #[allow(unused)]
+    fn data(&self) -> sails_rs::Vec<u8> {
+        match self {
+            Events::MyEvent1 { sender, amount } => Self::encode_sequence(&(amount,)),
+            Events::MyEvent2 => Self::encode_sequence(&()),
+        }
+    }
+}