Refactor event registration to allow multiple handlers per event

packages/cli/src/config_parsing/system_config.rs

@@ -1921,12 +1921,75 @@ impl Contract {
         events: Vec<Event>,
         abi: Abi,
     ) -> Result<Self> {
-        // TODO: Validatate that all event names are unique
         validate_names_valid_rescript(
             &events.iter().map(|e| e.name.clone()).collect(),
             "event".to_string(),
         )?;
 
+        // Codegen keys the generated event modules by name and routing looks
+        // events up by name, so two events on one contract can't share a name.
+        // Overloads (same name, different signature) are the usual cause — point
+        // at the `name` alias as the fix; a byte-identical copy just needs
+        // removing.
+        let mut seen_by_name: HashMap<&str, &Event> = HashMap::new();
+        for event in &events {
+            if let Some(existing) = seen_by_name.insert(&event.name, event) {
+                if existing.sighash == event.sighash {
+                    return Err(anyhow!(
+                        "Contract {name} defines the event \"{}\" more than once. \
+                         Please remove the duplicate.",
+                        event.name,
+                    ));
+                }
+                return Err(anyhow!(
+                    "Contract {name} has two events named \"{}\". Give one of them a \
+                     unique name with the \"name\" field so the generated code and \
+                     the indexer's routing can tell them apart.",
+                    event.name,
+                ));
+            }
+        }
+
+        // Two events on one contract that share a dispatch key are
+        // indistinguishable at routing time — one log/instruction would decode
+        // to both — so reject them here. The key mirrors the runtime `eventId`:
+        // sighash plus indexed-topic count for EVM, the discriminator for SVM
+        // (already program-scoped, since these are one program's instructions),
+        // the sighash for Fuel (a `LogData` logId or a fixed `mint`/`burn`/…).
+        // Names are unique by the check above, so a collision here is always
+        // between two differently-named events.
+        let mut seen_by_dispatch_key: HashMap<String, String> = HashMap::new();
+        for event in &events {
+            let dispatch_key = match &event.kind {
+                EventKind::Params(params) => {
+                    let indexed_count = params.iter().filter(|p| p.indexed).count();
+                    Some(format!("{}_{}", event.sighash, indexed_count))
+                }
+                // The router decodes the discriminator to bytes before matching,
+                // so `0x0f` and `0x0F` collide — lowercase before keying.
+                EventKind::Svm(svm) => Some(
+                    svm.discriminator
+                        .as_ref()
+                        .map(|d| d.to_lowercase())
+                        .unwrap_or_else(|| "none".to_string()),
+                ),
+                EventKind::Fuel(_) => Some(event.sighash.clone()),
+            };
+            if let Some(dispatch_key) = dispatch_key {
+                if let Some(existing) =
+                    seen_by_dispatch_key.insert(dispatch_key, event.name.clone())
+                {
+                    return Err(anyhow!(
+                        "Contract {name} has two events the indexer can't tell apart: \
+                         \"{existing}\" and \"{}\". They match the same on-chain data, so \
+                         the indexer can't decide which one a log belongs to. Please remove \
+                         one of them.",
+                        event.name,
+                    ));
+                }
+            }
+        }
+
         Ok(Self {
             name,
             events,