fix(sol-macro): correctly determine whether event parameters are hash…

…es (#735)

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

@@ -81,7 +81,7 @@ pub(super) fn expand(cx: &ExpCtxt<'_>, event: &ItemEvent) -> Result<TokenStream>
  let name = anon_name((i, p.name.as_ref()));
  let ty = expand_type(&p.ty, &cx.crates);
 
- if p.indexed_as_hash() {
+ if cx.indexed_as_hash(p) {
  quote! {
  <alloy_sol_types::sol_data::FixedBytes<32> as alloy_sol_types::EventTopic>::encode_topic(&self.#name)
  }
@@ -225,7 +225,7 @@ pub(super) fn expand(cx: &ExpCtxt<'_>, event: &ItemEvent) -> Result<TokenStream>
 fn expand_event_topic_type(param: &EventParameter, cx: &ExpCtxt<'_>) -> TokenStream {
  let alloy_sol_types = &cx.crates.sol_types;
  assert!(param.is_indexed());
- if param.is_abi_dynamic() {
+ if cx.indexed_as_hash(param) {
  quote_spanned! {param.ty.span()=> #alloy_sol_types::sol_data::FixedBytes<32> }
  } else {
  expand_type(&param.ty, &cx.crates)
@@ -239,7 +239,7 @@ fn expand_event_topic_field(
  cx: &ExpCtxt<'_>,
 ) -> TokenStream {
  let name = anon_name((i, name));
- let ty = if param.indexed_as_hash() {
+ let ty = if cx.indexed_as_hash(param) {
  let bytes32 = ast::Type::FixedBytes(name.span(), core::num::NonZeroU16::new(32).unwrap());
  ty::expand_rust_type(&bytes32, &cx.crates)
  } else {

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

@@ -545,7 +545,23 @@ impl<'ast> ExpCtxt<'ast> {
  }
 
  fn try_custom_type(&self, name: &SolPath) -> Option<&Type> {
- self.custom_types.resolve(name, &self.current_namespace)
+ self.custom_types.resolve(name, &self.current_namespace).inspect(|&ty| {
+ if ty.is_custom() {
+ abort!(
+ ty.span(),
+ "unresolved custom type in map";
+ note = name.span() => "name span";
+ );
+ }
+ })
+ }
+
+ fn indexed_as_hash(&self, param: &EventParameter) -> bool {
+ param.indexed_as_hash(self.custom_is_value_type())
+ }
+
+ fn custom_is_value_type(&self) -> impl Fn(&SolPath) -> bool + '_ {
+ move |ty| self.custom_type(ty).is_value_type(self.custom_is_value_type())
  }
 
  /// Returns the name of the function, adjusted for overloads.

crates/sol-types/src/types/event/mod.rs

@@ -47,6 +47,7 @@ pub trait SolEvent: Sized {
  ///
  /// For non-anonymous events, this will be the first topic (`topic0`).
  /// For anonymous events, this is unused, but is still present.
+ #[doc(alias = "SELECTOR")]
  const SIGNATURE_HASH: FixedBytes<32>;
 
  /// Whether the event is anonymous.

crates/sol-types/tests/macros/sol/mod.rs

@@ -1084,3 +1084,67 @@ fn regression_nested_namespaced_structs() {
  assert_eq!(inner::C::libCNested1Call::SIGNATURE, format!("libCNested1({c_nested1})"));
  assert_eq!(inner::C::libCNested2Call::SIGNATURE, format!("libCNested2({c_nested2})"));
 }
+
+// https://github.com/alloy-rs/core/issues/734
+#[test]
+fn event_indexed_udvt() {
+ use alloy_primitives::aliases::*;
+
+ sol! {
+ type Currency is address;
+ type PoolId is bytes32;
+
+ event Initialize(
+ PoolId indexed id,
+ Currency indexed currency0,
+ Currency indexed currency1,
+ uint24 fee,
+ int24 tickSpacing,
+ address hooks,
+ uint160 sqrtPriceX96,
+ int24 tick
+ );
+ }
+
+ assert_eq!(
+ Initialize::SIGNATURE,
+ "Initialize(bytes32,address,address,uint24,int24,address,uint160,int24)",
+ );
+ assert_eq!(
+ Initialize::SIGNATURE_HASH,
+ b256!("dd466e674ea557f56295e2d0218a125ea4b4f0f6f3307b95f85e6110838d6438"),
+ );
+
+ let _ = Initialize {
+ id: B256::ZERO,
+ currency0: Address::ZERO,
+ currency1: Address::ZERO,
+ fee: U24::ZERO,
+ tickSpacing: I24::ZERO,
+ hooks: Address::ZERO,
+ sqrtPriceX96: U160::ZERO,
+ tick: I24::ZERO,
+ };
+}
+
+#[test]
+fn event_indexed_elementary_arrays() {
+ sol! {
+ event AddrArray(address[1] indexed x);
+ event AddrDynArray(address[] indexed x);
+
+ type MyAddress is address;
+ event AddrUdvtArray(MyAddress[1] indexed y);
+ event AddrUdvtDynArray(MyAddress[] indexed y);
+ }
+
+ assert_eq!(AddrArray::SIGNATURE, "AddrArray(address[1])");
+ let _ = AddrArray { x: B256::ZERO };
+ assert_eq!(AddrDynArray::SIGNATURE, "AddrDynArray(address[])");
+ let _ = AddrDynArray { x: B256::ZERO };
+
+ assert_eq!(AddrUdvtArray::SIGNATURE, "AddrUdvtArray(address[1])");
+ let _ = AddrUdvtArray { y: B256::ZERO };
+ assert_eq!(AddrUdvtDynArray::SIGNATURE, "AddrUdvtDynArray(address[])");
+ let _ = AddrUdvtDynArray { y: B256::ZERO };
+}

crates/syn-solidity/src/item/event.rs

@@ -1,5 +1,6 @@
 use crate::{
- kw, utils::DebugPunctuated, ParameterList, SolIdent, Spanned, Type, VariableDeclaration,
+ kw, utils::DebugPunctuated, ParameterList, SolIdent, SolPath, Spanned, Type,
+ VariableDeclaration,
 };
 use proc_macro2::Span;
 use std::fmt;
@@ -153,10 +154,6 @@ impl ItemEvent {
  self.parameters.iter().filter(|p| p.is_indexed())
  }
 
- pub fn dynamic_params(&self) -> impl Iterator<Item = &EventParameter> {
- self.parameters.iter().filter(|p| p.is_abi_dynamic())
- }
-
  pub fn as_type(&self) -> Type {
  let mut ty = Type::Tuple(self.parameters.iter().map(|arg| arg.ty.clone()).collect());
  ty.set_span(self.span());
@@ -252,17 +249,14 @@ impl EventParameter {
  self.indexed.is_none()
  }
 
- /// Returns true if the event parameter is a dynamically sized type.
- pub fn is_abi_dynamic(&self) -> bool {
- self.ty.is_abi_dynamic()
- }
-
  /// Returns `true` if the event parameter is indexed and dynamically sized.
  /// These types are hashed, and then stored in the topics as specified in
  /// [the Solidity spec][ref].
  ///
+ /// `custom_is_value_type` accounts for custom value types.
+ ///
  /// [ref]: https://docs.soliditylang.org/en/latest/abi-spec.html#events
- pub fn indexed_as_hash(&self) -> bool {
- self.is_indexed() && self.is_abi_dynamic()
+ pub fn indexed_as_hash(&self, custom_is_value_type: impl Fn(&SolPath) -> bool) -> bool {
+ self.is_indexed() && !self.ty.is_value_type(custom_is_value_type)
  }
 }

crates/syn-solidity/src/type/mod.rs

@@ -278,21 +278,17 @@ impl Type {
  Ok(self)
  }
 
- /// Returns whether this type is ABI-encoded as a single EVM word (32
- /// bytes).
- pub const fn is_one_word(&self) -> bool {
- matches!(
- self,
- Self::Bool(_)
- | Self::Int(..)
- | Self::Uint(..)
- | Self::FixedBytes(..)
- | Self::Address(..)
- | Self::Function(_)
- )
+ /// Returns whether this type is ABI-encoded as a single EVM word (32 bytes).
+ ///
+ /// This is the same as [`is_value_type`](Self::is_value_type).
+ #[deprecated = "use `is_value_type` instead"]
+ pub fn is_one_word(&self, custom_is_value_type: impl Fn(&SolPath) -> bool) -> bool {
+ self.is_value_type(custom_is_value_type)
  }
 
  /// Returns whether this type is dynamic according to ABI rules.
+ ///
+ /// Note that this does not account for custom types, such as UDVTs.
  pub fn is_abi_dynamic(&self) -> bool {
  match self {
  Self::Bool(_)
@@ -308,17 +304,37 @@ impl Type {
  Self::Tuple(tuple) => tuple.is_abi_dynamic(),
 
  // not applicable
- Self::Mapping(_) => false,
+ Self::Mapping(_) => true,
  }
  }
 
  /// Returns whether this type is a value type.
  ///
  /// These types' variables are always passed by value.
  ///
+ /// `custom_is_value_type` accounts for custom value types.
+ ///
  /// See the [Solidity docs](https://docs.soliditylang.org/en/latest/types.html#value-types) for more information.
- pub const fn is_value_type(&self) -> bool {
- self.is_one_word()
+ pub fn is_value_type(&self, custom_is_value_type: impl Fn(&SolPath) -> bool) -> bool {
+ match self {
+ Self::Custom(custom) => custom_is_value_type(custom),
+ _ => self.is_value_type_simple(),
+ }
+ }
+
+ /// Returns whether this type is a simple value type.
+ ///
+ /// See [`is_value_type`](Self::is_value_type) for more information.
+ pub fn is_value_type_simple(&self) -> bool {
+ matches!(
+ self,
+ Self::Bool(_)
+ | Self::Int(..)
+ | Self::Uint(..)
+ | Self::FixedBytes(..)
+ | Self::Address(..)
+ | Self::Function(_)
+ )
  }
 
  pub const fn is_array(&self) -> bool {