gnd: Test scaffold type mappings across scalars and arrays

Cover every schema-side type-mapping row in one event, and the mapping cast
for a fixed-size address array end-to-end. The fixed-size array rows
(`address[3]`, `uint256[3]`, `uint8[3]`, `bool[2]`, `string[2]`, `bytes32[4]`)
regress-guard the string matcher that could not see `[N]` and scaffolded them
to non-building fields.

Author: incrypto32

gnd/src/scaffold/manifest.rs

@@ -623,4 +623,21 @@ mod tests {
         let fields: Vec<&str> = leaves.iter().map(|l| l.field.as_str()).collect();
         assert_eq!(fields, vec!["value", "value2", "value1"]);
     }
+
+    #[test]
+    fn test_flatten_component_less_tuple_falls_back_to_bytes() {
+        // alloy accepts a `tuple` with no components (solc never emits one), whose
+        // selector type is the bare "tuple" and does not resolve. Scaffolding must
+        // fall back to a single Bytes leaf, not panic like codegen's resolver.
+        let input = EventParam {
+            name: "data".to_string(),
+            ty: "tuple".to_string(),
+            components: vec![],
+            ..Default::default()
+        };
+        let leaves = flatten_event_inputs(&[input]);
+        assert_eq!(leaves.len(), 1);
+        assert_eq!(leaves[0].field, "data");
+        assert_eq!(leaves[0].ty, DynSolType::Bytes);
+    }
 }

gnd/src/scaffold/mapping.rs

@@ -533,6 +533,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_generate_mapping_casts_fixed_size_address_array() {
+        // A non-indexed `address[N]` reaches the entity as an array, so it needs
+        // the same upcast as `address[]`; a fixed uint array does not.
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Signers",
+                "inputs": [
+                    {"name": "owners", "type": "address[3]"},
+                    {"name": "amounts", "type": "uint256[3]"}
+                ]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            contract_name: "Vault".to_string(),
+            abi: Some(abi),
+            index_events: true,
+            ..Default::default()
+        };
+
+        let mapping = generate_mapping(&options);
+        assert!(
+            mapping.contains("entity.owners = changetype<Bytes[]>(event.params.owners)"),
+            "{}",
+            mapping
+        );
+        assert!(
+            mapping.contains("entity.amounts = event.params.amounts\n"),
+            "{}",
+            mapping
+        );
+    }
+
     #[test]
     fn test_needs_bytes_array_cast() {
         let cast = |t: &str| needs_bytes_array_cast(&t.parse::<DynSolType>().unwrap());

gnd/src/scaffold/schema.rs

@@ -280,6 +280,67 @@ mod tests {
         assert_eq!(graphql_type_of("uint64[]"), "[BigInt!]");
     }
 
+    #[test]
+    fn test_generate_schema_covers_all_type_mappings() {
+        // One event exercising every schema-side mapping row, including the
+        // fixed-size arrays the old `ends_with("[]")` matcher could not see and
+        // that scaffolded to non-building scalar fields.
+        let param = |name: &str, ty: &str| json!({"name": name, "type": ty, "indexed": false});
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "AllTypes",
+                "inputs": [
+                    param("addr", "address"),
+                    param("flag", "bool"),
+                    param("text", "string"),
+                    param("tiny", "uint8"),      // i32 band
+                    param("mid", "uint32"),      // i64 band
+                    param("big", "uint256"),     // BigInt
+                    param("addrsDyn", "address[]"),
+                    param("addrsFixed", "address[3]"),
+                    param("numsFixed", "uint256[3]"),
+                    param("tinyFixed", "uint8[3]"),
+                    param("flagsFixed", "bool[2]"),
+                    param("textFixed", "string[2]"),
+                    param("hashesFixed", "bytes32[4]"),
+                    param("tinyDyn", "int8[]"),  // i32 band keeps Int
+                    param("midDyn", "int40[]"),  // i64 band collapses to BigInt
+                ]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            index_events: true,
+            ..Default::default()
+        };
+        let schema = generate_schema(&options);
+
+        for (field, ty) in [
+            ("addr", "Bytes!"),
+            ("flag", "Boolean!"),
+            ("text", "String!"),
+            ("tiny", "Int!"),
+            ("mid", "Int8!"),
+            ("big", "BigInt!"),
+            ("addrsDyn", "[Bytes!]!"),
+            ("addrsFixed", "[Bytes!]!"),
+            ("numsFixed", "[BigInt!]!"),
+            ("tinyFixed", "[Int!]!"),
+            ("flagsFixed", "[Boolean!]!"),
+            ("textFixed", "[String!]!"),
+            ("hashesFixed", "[Bytes!]!"),
+            ("tinyDyn", "[Int!]!"),
+            ("midDyn", "[BigInt!]!"),
+        ] {
+            assert!(
+                schema.contains(&format!("{field}: {ty}")),
+                "expected `{field}: {ty}` in:\n{schema}"
+            );
+        }
+    }
+
     #[test]
     fn test_generate_schema_unrolls_tuple() {
         let abi = json!([