neo_solidity/solidity/convert/
functions.rs

1fn convert_function(
2    function: FunctionIR,
3    struct_types: &[StructTypeMetadata],
4    enum_types: &[EnumTypeMetadata],
5    contract_types: &[String],
6    has_explicit_on_nep17_payment: bool,
7    type_aliases: &std::collections::HashMap<String, String>,
8) -> FunctionMetadata {
9    if matches!(function.ty, FunctionTy::Receive) {
10        if has_explicit_on_nep17_payment {
11            let name = "receive".to_string();
12            let neo_name = name.clone();
13            let selector = compute_function_selector(&name, &[]);
14
15            return FunctionMetadata {
16                neo_name,
17                name,
18                kind: FunctionKind::Regular,
19                parameters: Vec::new(),
20                return_parameters: Vec::new(),
21                state_mutability: StateMutability::Payable,
22                visibility: VisibilityKind::External,
23                offset: 0,
24                body: function.body,
25                selector,
26                is_virtual: function.is_virtual,
27                is_override: function.is_override,
28                documentation: function.doc.into(),
29            };
30        }
31
32        let name = "onNEP17Payment".to_string();
33        let neo_name = name.clone();
34        let parameters = vec![
35            ParameterMetadata {
36                name: Some("from".to_string()),
37                ty: "address".to_string(),
38                neo_type: Some(NeoType::Address),
39                storage: None,
40            },
41            ParameterMetadata {
42                name: Some("amount".to_string()),
43                ty: "uint256".to_string(),
44                neo_type: Some(NeoType::Integer {
45                    signed: false,
46                    bits: 256,
47                }),
48                storage: None,
49            },
50            ParameterMetadata {
51                name: Some("data".to_string()),
52                ty: "Any".to_string(),
53                neo_type: Some(NeoType::Any),
54                storage: None,
55            },
56        ];
57
58        let param_signatures: Vec<String> = parameters
59            .iter()
60            .map(|param| canonical_param_type(&param.ty))
61            .collect();
62        let selector = compute_function_selector(&name, &param_signatures);
63
64        return FunctionMetadata {
65            neo_name,
66            name,
67            kind: FunctionKind::Regular,
68            parameters,
69            return_parameters: Vec::new(),
70            state_mutability: StateMutability::Payable,
71            visibility: VisibilityKind::External,
72            offset: 0,
73            body: function.body,
74            selector,
75            is_virtual: false,
76            is_override: false,
77            documentation: function.doc.into(),
78        };
79    }
80
81    let parameters: Vec<ParameterMetadata> = function
82        .parameters
83        .into_iter()
84        .map(|param| convert_parameter(param, struct_types, enum_types, contract_types, type_aliases))
85        .collect();
86
87    let return_parameters = function
88        .returns
89        .into_iter()
90        .map(|param| convert_parameter(param, struct_types, enum_types, contract_types, type_aliases))
91        .collect();
92
93    let param_signatures: Vec<String> = parameters
94        .iter()
95        .map(|param| canonical_param_type(&param.ty))
96        .collect();
97
98    let name = function.name;
99    let selector = compute_function_selector(&name, &param_signatures);
100
101    FunctionMetadata {
102        neo_name: name.clone(),
103        name,
104        kind: match function.ty {
105            FunctionTy::Constructor => FunctionKind::Constructor,
106            _ => FunctionKind::Regular,
107        },
108        parameters,
109        return_parameters,
110        state_mutability: match function.mutability {
111            MutabilityKind::Pure => StateMutability::Pure,
112            MutabilityKind::View => StateMutability::View,
113            MutabilityKind::Payable => StateMutability::Payable,
114            MutabilityKind::NonPayable => StateMutability::NonPayable,
115        },
116        visibility: function.visibility,
117        offset: 0,
118        body: function.body,
119        selector,
120        is_virtual: function.is_virtual,
121        is_override: function.is_override,
122        documentation: function.doc.into(),
123    }
124}
125
126fn convert_parameter(
127    param: ParameterIR,
128    struct_types: &[StructTypeMetadata],
129    enum_types: &[EnumTypeMetadata],
130    contract_types: &[String],
131    type_aliases: &std::collections::HashMap<String, String>,
132) -> ParameterMetadata {
133    let ty = param.ty;
134    let neo_type = NeoType::from_solidity_with_aliases(&ty, struct_types, enum_types, contract_types, type_aliases).ok();
135    ParameterMetadata {
136        name: param.name,
137        ty,
138        neo_type,
139        storage: param.storage,
140    }
141}
neo_solidity/solidity/convert/functions.rs

neo_solidity/solidity/convert/
functions.rs
