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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! Code generator unit tests.
//!
//! Tests code generation through compilation.

use neo_devpack_solidity::cli::compile_contracts;

#[test]
fn test_simple_arithmetic() {
    let source = r#"
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    contract Arith {
        function add(uint256 a, uint256 b) public pure returns (uint256) {
            return a + b;
        }
    }
    "#;
    assert!(compile_contracts(source, false, 2).is_ok());
}

#[test]
fn test_function_compilation() {
    let source = r#"
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    contract Funcs {
        function addOne(uint256 x) public pure returns (uint256) {
            return x + 1;
        }
    }
    "#;
    assert!(compile_contracts(source, false, 2).is_ok());
}

#[test]
fn test_for_loop_compiles() {
    let source = r#"
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    contract Loop {
        function sum(uint256 n) public pure returns (uint256) {
            uint256 total = 0;
            for (uint256 i = 0; i < n; i++) {
                total = total + i;
            }
            return total;
        }
    }
    "#;
    assert!(compile_contracts(source, false, 2).is_ok());
}

#[test]
fn test_while_loop_compiles() {
    let source = r#"
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    contract Loop {
        function countdown(uint256 n) public pure returns (uint256) {
            uint256 count = 0;
            while (n > 0) {
                n--;
                count++;
            }
            return count;
        }
    }
    "#;
    assert!(compile_contracts(source, false, 2).is_ok());
}

#[test]
fn test_break_statement_compiles() {
    let source = r#"
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    contract Loop {
        function findFirst(uint256[] memory arr, uint256 target) public pure returns (uint256) {
            for (uint256 i = 0; i < arr.length; i++) {
                if (arr[i] == target) {
                    break;
                }
            }
            return 0;
        }
    }
    "#;
    assert!(compile_contracts(source, false, 2).is_ok());
}

#[test]
fn test_continue_statement_compiles() {
    let source = r#"
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    contract Loop {
        function countEven(uint256[] memory arr) public pure returns (uint256) {
            uint256 count = 0;
            for (uint256 i = 0; i < arr.length; i++) {
                if (arr[i] % 2 != 0) {
                    continue;
                }
                count++;
            }
            return count;
        }
    }
    "#;
    assert!(compile_contracts(source, false, 2).is_ok());
}