chore: Review fixes

sylvia-derive/src/contract/communication/reply.rs

@@ -11,7 +11,36 @@
 use crate::types::msg_variant::{MsgVariant, MsgVariants};
 use crate::utils::emit_turbofish;
 
-const NUMBER_OF_DATA_FIELDS: usize = 1;
+const NO_ALLOWED_DATA_FIELDS: usize = 1;
+const NO_ALLOWED_RAW_PAYLOAD_FIELDS: usize = 1;
+
+/// Make sure that there are no additional parameters between ones marked
+/// with `sv::data` and `sv::payload` and after the one marked with `sv::payload`.
+fn assert_no_redundant_params(payload: &[&MsgField]) {
+    let payload_param = payload.iter().enumerate().find(|(_, field)| {
+        ParsedSylviaAttributes::new(field.attrs().iter())
+            .payload
+            .is_some()
+    });
+
+    if payload.len() == NO_ALLOWED_RAW_PAYLOAD_FIELDS {
+        return;
+    }
+
+    let Some((index, payload_param)) = payload_param else {
+        return;
+    };
+
+    if index == 0 {
+        emit_error!(payload[1].name().span(), "Redundant payload parameter.";
+            note = payload_param.name().span() => "Expected no parameters after the parameter marked with `#[sv::payload(raw)]`."
+        )
+    } else {
+        emit_error!(payload[0].name().span(), "Redundant payload parameter.";
+            note = payload_param.name().span() => "Expected no parameters between the parameter marked with `#[sv::data]` and `#[sv::payload(raw)]`."
+        )
+    }
+}
 
 pub struct Reply<'a> {
     source: &'a ItemImpl,
@@ -208,10 +237,11 @@
         variant.validate_fields_attributes();
         let payload = variant.fields().iter();
         let payload = if data.is_some() || variant.msg_attr().reply_on() != ReplyOn::Success {
-            payload.skip(NUMBER_OF_DATA_FIELDS).collect::<Vec<_>>()
+            payload.skip(NO_ALLOWED_DATA_FIELDS).collect::<Vec<_>>()
         } else {
             payload.collect::<Vec<_>>()
         };
+        assert_no_redundant_params(&payload);
         let method_name = variant.function_name();
         let reply_on = variant.msg_attr().reply_on();
 
@@ -523,8 +553,18 @@
         let sylvia = crate_module();
         let data = ParsedSylviaAttributes::new(self.attrs().iter()).data;
         let missing_data_err = "Missing reply data field.";
+        let transaction_id = quote! {
+            env
+                .transaction
+                .as_ref()
+                .map(|tx| format!("{}", &tx.index))
+                .unwrap_or_else(|| "Missing".to_string())
+        };
         let invalid_reply_data_err = quote! {
-            format! {"Invalid reply data: {}\nSerde error while deserializing {}", data, err}
+            format! {"Invalid reply data at block height: {}, transaction id: {}.\nSerde error while deserializing {}",
+                env.block.height,
+                #transaction_id,
+                err}
         };
         let execute_data_deserialization = quote! {
             let deserialized_data =

sylvia/tests/reply_data.rs

@@ -336,9 +336,11 @@ fn data_opt() {
         .call(&owner)
         .unwrap_err();
     assert_eq!(
-            err,
-            StdError::generic_err("Invalid reply data: SW52YWxpZERhdGE=\nSerde error while deserializing Error parsing into type alloc::string::String: Invalid type").into()
-        );
+        err,
+        StdError::generic_err(
+            "Invalid reply data at block height: 12345, transaction id: 0.\nSerde error while deserializing Error parsing into type alloc::string::String: Invalid type"
+        ).into()
+    );
 
     contract
         .send_message_expecting_data(data.clone(), DATA_OPT_REPLY_ID)
@@ -377,7 +379,12 @@ fn data() {
         .send_message_expecting_data(invalid_data, DATA_REPLY_ID)
         .call(&owner)
         .unwrap_err();
-    assert_eq!(err, StdError::generic_err("Invalid reply data: SW52YWxpZERhdGE=\nSerde error while deserializing Error parsing into type alloc::string::String: Invalid type").into());
+    assert_eq!(
+        err,
+        StdError::generic_err(
+            "Invalid reply data at block height: 12345, transaction id: 0.\nSerde error while deserializing Error parsing into type alloc::string::String: Invalid type"
+        ).into()
+    );
 
     contract
         .send_message_expecting_data(data, DATA_REPLY_ID)

sylvia/tests/ui/method_signature/reply.rs

@@ -1,6 +1,6 @@
-#![allow(unused_imports)]
+#![allow(unused_imports, unused_variables)]
 use sylvia::ctx::{InstantiateCtx, ReplyCtx};
-use sylvia::cw_std::{Binary, Response, StdResult};
+use sylvia::cw_std::{Addr, Binary, Response, StdResult};
 
 pub mod mismatched_params {
     use super::*;
@@ -81,4 +81,48 @@ pub mod mismatched_param_arity {
     }
 }
 
+pub mod redundant_params {
+    use super::*;
+
+    pub struct Contract {}
+
+    #[sylvia::contract]
+    #[sv::features(replies)]
+    impl Contract {
+        pub const fn new() -> Self {
+            Self {}
+        }
+
+        #[sv::msg(instantiate)]
+        fn instantiate(&self, _ctx: InstantiateCtx) -> StdResult<Response> {
+            Ok(Response::new())
+        }
+
+        #[sv::msg(reply, reply_on=success)]
+        fn first_reply(
+            &self,
+            _ctx: ReplyCtx,
+            #[sv::data(opt, raw)] _data: Option<Binary>,
+            redundant_between1: u32,
+            redudnant_between2: String,
+            #[sv::payload(raw)] param: String,
+            redundant_after1: Binary,
+            redundant_after2: Addr,
+        ) -> StdResult<Response> {
+            Ok(Response::new())
+        }
+
+        #[sv::msg(reply, reply_on=success)]
+        fn second_reply(
+            &self,
+            _ctx: ReplyCtx,
+            #[sv::data(opt, raw)] _data: Option<Binary>,
+            #[sv::payload(raw)] param: String,
+            redundant: Binary,
+        ) -> StdResult<Response> {
+            Ok(Response::new())
+        }
+    }
+}
+
 fn main() {}

sylvia/tests/ui/method_signature/reply.stderr

@@ -17,3 +17,21 @@ error: Mismatched quantity of method parameters.
    |
 62 |         fn first_reply(
    |            ^^^^^^^^^^^
+
+error: Redundant payload parameter.
+
+         = note: Expected no parameters between the parameter marked with `#[sv::data]` and `#[sv::payload(raw)]`.
+
+   --> tests/ui/method_signature/reply.rs:106:13
+    |
+106 |             redundant_between1: u32,
+    |             ^^^^^^^^^^^^^^^^^^
+
+error: Redundant payload parameter.
+
+         = note: Expected no parameters after the parameter marked with `#[sv::payload(raw)]`.
+
+   --> tests/ui/method_signature/reply.rs:121:13
+    |
+121 |             redundant: Binary,
+    |             ^^^^^^^^^