Merge branch 'main' into fix/overloaded-event-enum-derives

Author: pjdurden

.github/dependabot.yml

@@ -1,8 +1,15 @@
 version: 2
 updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
+  - package-ecosystem: github-actions
+    directory: /
     schedule:
-      interval: "weekly"
+      interval: weekly
+      day: monday
+      time: "09:00"
+      timezone: UTC
     cooldown:
       default-days: 7
+    groups:
+      ci-weekly:
+        patterns:
+          - '*'

Cargo.toml

@@ -60,7 +60,7 @@ schemars = { version = "1", default-features = false }
 rkyv = "0.8"
 
 # macros
-proc-macro-error2 = ">=2.0.0, <=2.0.1" # We directly use the `entry_point` private API.
+proc-macro-error3 = ">=3.0.0, <=3.0.1" # We directly use the `entry_point` private API.
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = "2.0"

crates/dyn-abi/src/dynamic/event.rs

@@ -73,18 +73,29 @@ impl DynSolEvent {
             }
         }
 
+        let not_anonymous = !self.is_anonymous() as usize;
         let indexed = self
             .indexed
             .iter()
-            .zip(topics.by_ref().take(self.indexed.len()))
-            .map(|(ty, topic)| {
-                let value = ty.decode_event_topic(topic);
-                Ok(value)
+            .enumerate()
+            .map(|(i, ty)| match topics.next() {
+                Some(topic) => Ok(ty.decode_event_topic(topic)),
+                // Ran out of topics: report the count we actually have (event hash + `i`
+                // indexed topics consumed so far) rather than letting the body decode below
+                // fail with a confusing `Overrun`.
+                None => Err(Error::TopicLengthMismatch {
+                    expected: num_topics,
+                    actual: not_anonymous + i,
+                }),
             })
             .collect::<Result<_>>()?;
 
-        let body = self.body.abi_decode_sequence(data)?.into_fixed_seq().expect("body is a tuple");
-
+        // Validate the topic count before decoding the body. A log whose topic count does not
+        // match this event (e.g. an ERC-721 `Transfer` decoded against the ERC-20 `Transfer`
+        // ABI, which shares the same `topic0`) must surface as `TopicLengthMismatch`, not as an
+        // `Overrun` from trying to read body words that the extra topics displaced. The early
+        // `size_hint` check above only fires for exact-size iterators, so this also covers
+        // iterators (`filter`/`map`/streaming) that don't report an exact length.
         let remaining = topics.count();
         if remaining > 0 {
             return Err(Error::TopicLengthMismatch {
@@ -93,6 +104,8 @@ impl DynSolEvent {
             });
         }
 
+        let body = self.body.abi_decode_sequence(data)?.into_fixed_seq().expect("body is a tuple");
+
         Ok(DecodedEvent { selector: self.topic_0, indexed, body })
     }
 
@@ -215,4 +228,57 @@ mod test {
         let encoded = decoded.encode_log_data();
         assert_eq!(encoded, log);
     }
+
+    // ERC-20 and ERC-721 `Transfer` share the same `topic0`, so a topic-only filter matches
+    // both. Decoding an ERC-721 transfer (4 topics, empty data) against the ERC-20 ABI used to
+    // fail with a confusing `Overrun` when the topic iterator didn't report an exact size,
+    // because the body was decoded before the topic count was validated. See alloy#2243.
+    #[test]
+    fn topic_count_is_validated_before_body() {
+        let t0 = b256!("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef");
+        // event Transfer(address indexed from, address indexed to, uint256 value)
+        let event = DynSolEvent {
+            topic_0: Some(t0),
+            indexed: vec![DynSolType::Address, DynSolType::Address],
+            body: DynSolType::Tuple(vec![DynSolType::Uint(256)]),
+        };
+
+        // ERC-721-style log: 4 topics (sig + from + to + tokenId), empty data.
+        let topics = [
+            t0,
+            b256!("0x000000000000000000000000d9a442856c234a39a81a089c06451ebaa4306a72"),
+            b256!("0x0000000000000000000000002a3dd3eb832af982ec71669e178424b10dca2ede"),
+            b256!("0x0000000000000000000000000000000000000000000000000000000000000290"),
+        ];
+
+        // Exact-size iterator: caught by the up-front `size_hint` check.
+        let err = event.decode_log_parts(topics.iter().copied(), &[]).unwrap_err();
+        assert!(
+            matches!(err, Error::TopicLengthMismatch { expected: 3, actual: 4 }),
+            "exact iterator: {err:?}"
+        );
+
+        // Non-exact iterator (e.g. `filter`): previously returned `Overrun`.
+        let err = event.decode_log_parts(topics.iter().copied().filter(|_| true), &[]).unwrap_err();
+        assert!(
+            matches!(err, Error::TopicLengthMismatch { expected: 3, actual: 4 }),
+            "non-exact iterator: {err:?}"
+        );
+    }
+
+    #[test]
+    fn too_few_topics_is_a_length_mismatch() {
+        let t0 = b256!("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef");
+        let event = DynSolEvent {
+            topic_0: Some(t0),
+            indexed: vec![DynSolType::Address, DynSolType::Address],
+            body: DynSolType::Tuple(vec![DynSolType::Uint(256)]),
+        };
+
+        // Only sig + one indexed topic, supplied via a non-exact iterator.
+        let topics =
+            [t0, b256!("0x000000000000000000000000d9a442856c234a39a81a089c06451ebaa4306a72")];
+        let err = event.decode_log_parts(topics.iter().copied().filter(|_| true), &[]).unwrap_err();
+        assert!(matches!(err, Error::TopicLengthMismatch { expected: 3, actual: 2 }), "{err:?}");
+    }
 }

crates/primitives/Cargo.toml

@@ -132,6 +132,7 @@ std = [
     "indexmap?/std",
     "k256?/std",
     "secp256k1?/std",
+    "secp256k1?/global-context",
     "keccak-asm?/std",
     "proptest?/std",
     "rand?/std",

crates/primitives/src/signature/sig.rs

@@ -407,8 +407,15 @@ impl Signature {
         let this = self.normalized_s();
         let sig = this.to_secp256k1()?;
         let msg = secp256k1::Message::from_digest(prehash.0);
-        let secp = secp256k1::Secp256k1::verification_only();
-        secp.recover_ecdsa(msg, &sig).map_err(Into::into)
+        #[cfg(feature = "std")]
+        {
+            secp256k1::SECP256K1.recover_ecdsa(msg, &sig).map_err(Into::into)
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            let secp = secp256k1::Secp256k1::verification_only();
+            secp.recover_ecdsa(msg, &sig).map_err(Into::into)
+        }
     }
 
     /// Returns the `r` component of this signature.

crates/sol-macro-expander/Cargo.toml

@@ -35,7 +35,7 @@ syn = { workspace = true, features = ["extra-traits"] }
 heck = "0.5"
 hex.workspace = true
 indexmap = "2"
-proc-macro-error2.workspace = true
+proc-macro-error3.workspace = true
 sha3.workspace = true
 
 # json

crates/sol-macro-expander/src/expand/mod.rs

@@ -7,7 +7,7 @@ use ast::{
     Spanned, Type, VariableDeclaration, Visit, VisitMut, visit_mut,
 };
 use indexmap::IndexMap;
-use proc_macro_error2::{abort, emit_error};
+use proc_macro_error3::{abort, emit_error};
 use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
 use quote::{TokenStreamExt, format_ident, quote};
 use std::{

crates/sol-macro-expander/src/expand/struct.rs

@@ -207,7 +207,7 @@ fn expand_encode_type_fns(
             Some(Item::Enum(_)) => *ty = Type::Uint(ty.span(), NonZeroU16::new(8)),
             Some(Item::Udt(udt)) => *ty = udt.ty.clone(),
             Some(item) => {
-                proc_macro_error2::abort!(item.span(), "Invalid type in struct field: {:?}", item)
+                proc_macro_error3::abort!(item.span(), "Invalid type in struct field: {:?}", item)
             }
         }
     });

crates/sol-macro-expander/src/expand/ty.rs

@@ -2,7 +2,7 @@
 
 use super::ExpCtxt;
 use ast::{Item, Parameters, Spanned, Type, TypeArray};
-use proc_macro_error2::{abort, emit_error};
+use proc_macro_error3::{abort, emit_error};
 use proc_macro2::{Ident, Literal, Span, TokenStream};
 use quote::{ToTokens, quote_spanned};
 use std::{fmt, num::NonZeroU16};

crates/sol-macro-expander/src/utils.rs

@@ -81,17 +81,17 @@ impl<T: ToTokens> ToTokens for ExprArray<T> {
     }
 }
 
-/// Applies [`proc_macro_error2`] programmatically.
+/// Applies [`proc_macro_error3`] programmatically.
 pub(crate) fn pme_compat(f: impl FnOnce() -> TokenStream) -> TokenStream {
     pme_compat_result(|| Ok(f())).unwrap()
 }
 
-/// Applies [`proc_macro_error2`] programmatically.
+/// Applies [`proc_macro_error3`] programmatically.
 pub(crate) fn pme_compat_result(
     f: impl FnOnce() -> syn::Result<TokenStream>,
 ) -> syn::Result<TokenStream> {
     let mut r = None;
-    let e = proc_macro_error2::entry_point(
+    let e = proc_macro_error3::entry_point(
         std::panic::AssertUnwindSafe(|| {
             r = Some(f());
             Default::default()