neo-devpack-solidity 0.22.0

Production-focused Solidity-to-NeoVM compilation system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

fn convert_event(
    event: EventIR,
    struct_types: &[StructTypeMetadata],
    enum_types: &[EnumTypeMetadata],
    contract_types: &[String],
    type_aliases: &std::collections::HashMap<String, String>,
) -> EventMetadata {
    let normalized = normalize_event_signature(&event.name, &event.parameters);
    EventMetadata {
        name: event.name,
        normalized_name: normalized,
        parameters: event
            .parameters
            .into_iter()
            .map(|param| {
                let ty = param.ty;
                let neo_type = NeoType::from_solidity_with_aliases(
                    &ty,
                    struct_types,
                    enum_types,
                    contract_types,
                    type_aliases,
                )
                .ok();

                EventParameter {
                    name: param.name,
                    ty,
                    indexed: param.indexed,
                    neo_type,
                }
            })
            .collect(),
        anonymous: event.anonymous,
    }
}

fn normalize_event_signature(name: &str, params: &[crate::frontend::EventParameterIR]) -> String {
    fn canonical_param_type(ty: &str) -> String {
        let mut parts = ty.split_whitespace();
        match parts.next() {
            Some("struct" | "enum") => parts.next().unwrap_or_default().to_string(),
            Some(first) => first.to_string(),
            None => String::new(),
        }
    }

    let base = name.trim().to_ascii_lowercase();
    let param_types: Vec<String> = params
        .iter()
        .map(|param| canonical_param_type(&param.ty).to_ascii_lowercase())
        .collect();

    // `event Foo` with no parameters is valid Solidity syntax (treated as Foo()).
    if param_types.is_empty() {
        format!("{base}()")
    } else {
        // Preserve the declared order; Neo ABI dispatches events by name only,
        // so we use this signature only for de-duplication and validation.
        format!("{base}({})", param_types.join(","))
    }
}