resolc 1.1.0

Solidity frontend for the revive compiler
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

//! The tests for running `resolc` with bin option.

use crate::{
    cli_utils::{
        absolute_path, assert_command_success, execute_command, CommandResult, ResolcOptSettings,
        SolcOptSettings, SOLIDITY_CONTRACT_PATH, STANDARD_JSON_CONTRACTS_PATH,
        YUL_MEMSET_CONTRACT_PATH,
    },
    SolcCompiler,
};

/// The starting hex value of a PVM blob (encoding of `"PVM"`).
const PVM_BLOB_START: &str = "50564d";

/// The starting hex value of an EVM blob compiled from Solidity.
const EVM_BLOB_START_FROM_SOLIDITY: &str = "6080";

/// The starting hex value of an EVM blob compiled from Yul.
/// (Blobs compiled from Yul do not have consistent starting hex values.)
const EVM_BLOB_START_FROM_YUL: &str = "";

/// Asserts that the `resolc` output contains a PVM blob.
fn assert_pvm_blob(result: &CommandResult) {
    assert_binary_blob(result, "Binary:\n", PVM_BLOB_START);
}

/// Asserts that the `solc` output from compiling Solidity contains an EVM blob.
fn assert_evm_blob_from_solidity(result: &CommandResult) {
    assert_binary_blob(result, "Binary:\n", EVM_BLOB_START_FROM_SOLIDITY);
}

/// Asserts that the `solc` output from compiling Yul contains an EVM blob.
fn assert_evm_blob_from_yul(result: &CommandResult) {
    assert_binary_blob(result, "Binary representation:\n", EVM_BLOB_START_FROM_YUL);
}

/// Asserts that the `resolc` output of compiling Solidity from JSON input contains a PVM blob.
/// - `result`: The result of running the command.
/// - `file_name`: The file name of the contract to verify the existence of a PVM blob for (corresponds to the name specified as a `source` in the JSON input).
/// - `contract_name`: The name of the contract to verify the existence of a PVM blob for.
fn assert_pvm_blob_from_json(result: &CommandResult, file_name: &str, contract_name: &str) {
    assert_binary_blob_from_json(result, file_name, contract_name, PVM_BLOB_START);
}

/// Asserts that the `solc` output of compiling Solidity from JSON input contains an EVM blob.
/// - `result`: The result of running the command.
/// - `file_name`: The file name of the contract to verify the existence of an EVM blob for (corresponds to the name specified as a `source` in the JSON input).
/// - `contract_name`: The name of the contract to verify the existence of an EVM blob for.
fn assert_evm_blob_from_json(result: &CommandResult, file_name: &str, contract_name: &str) {
    assert_binary_blob_from_json(
        result,
        file_name,
        contract_name,
        EVM_BLOB_START_FROM_SOLIDITY,
    );
}

/// Asserts that the output of a compilation contains a binary blob.
/// - `result`: The result of running the command.
/// - `blob_prefix`: The `stdout` message immediately preceding the binary blob representation.
/// - `blob_start`: The starting hex value of the binary blob.
fn assert_binary_blob(result: &CommandResult, blob_prefix: &str, blob_start: &str) {
    assert_command_success(result, "Executing the command");

    let is_blob = result
        .stdout
        .split(blob_prefix)
        .collect::<Vec<&str>>()
        .get(1)
        .is_some_and(|blob| blob.starts_with(blob_start));

    assert!(
        is_blob,
        "expected a binary blob starting with `{blob_start}`",
    );
}

/// Asserts that the output of compiling Solidity from JSON input contains a binary blob.
/// - `result`: The result of running the command.
/// - `file_name`: The file name of the contract to verify the existence of a binary blob for (corresponds to the name specified as a `source` in the JSON input).
/// - `contract_name`: The name of the contract to verify the existence of a binary blob for.
/// - `blob_start`: The starting hex value of the binary blob.
///
/// See [output description](https://docs.soliditylang.org/en/latest/using-the-compiler.html#output-description)
/// for more details on the JSON output format.
fn assert_binary_blob_from_json(
    result: &CommandResult,
    file_name: &str,
    contract_name: &str,
    blob_start: &str,
) {
    assert_command_success(result, "Executing the command with stdin JSON input");

    let parsed_output: serde_json::Value =
        serde_json::from_str(&result.stdout).expect("expected valid JSON output");
    let contract = &parsed_output["contracts"][file_name][contract_name];

    let errors = contract["errors"].as_array();
    assert!(
        errors.is_none(),
        "errors found for JSON-provided contract `{contract_name}` in `{file_name}`: {}",
        get_first_json_error(errors.unwrap()),
    );

    let blob = contract["evm"]["bytecode"]["object"]
        .as_str()
        .unwrap_or_else(|| {
            panic!(
                "expected a binary blob for JSON-provided contract `{contract_name}` in `{file_name}`",
            )
        });
    assert!(
        blob.starts_with(blob_start),
        "expected a binary blob starting with `{blob_start}`",
    );
}

/// Gets the first error message reported when compiling from JSON input.
///
/// See [output description](https://docs.soliditylang.org/en/latest/using-the-compiler.html#output-description)
/// for more details on the JSON output format.
fn get_first_json_error(errors: &[serde_json::Value]) -> &str {
    errors.first().unwrap()["message"].as_str().unwrap()
}

/// This test mimics the command used in the `resolc` benchmarks when compiling Solidity.
#[test]
fn compiles_solidity_to_binary_blob() {
    let path = absolute_path(SOLIDITY_CONTRACT_PATH);
    let resolc_arguments = &[&path, "--bin", ResolcOptSettings::PERFORMANCE];
    let solc_arguments = &[
        &path,
        "--bin",
        "--via-ir",
        "--optimize",
        "--optimize-runs",
        SolcOptSettings::PERFORMANCE,
    ];

    let resolc_result = execute_command(crate::DEFAULT_EXECUTABLE_NAME, resolc_arguments, None);
    assert_pvm_blob(&resolc_result);

    let solc_result = execute_command(SolcCompiler::DEFAULT_EXECUTABLE_NAME, solc_arguments, None);
    assert_evm_blob_from_solidity(&solc_result);
}

/// This test mimics the command used in the `resolc` benchmarks when compiling Yul.
#[test]
fn compiles_yul_to_binary_blob() {
    let path = absolute_path(YUL_MEMSET_CONTRACT_PATH);
    let resolc_arguments = &[&path, "--yul", "--bin", ResolcOptSettings::PERFORMANCE];
    let solc_arguments = &[
        &path,
        "--strict-assembly",
        "--bin",
        "--optimize",
        "--optimize-runs",
        SolcOptSettings::PERFORMANCE,
    ];

    let resolc_result = execute_command(crate::DEFAULT_EXECUTABLE_NAME, resolc_arguments, None);
    assert_pvm_blob(&resolc_result);

    let solc_result = execute_command(SolcCompiler::DEFAULT_EXECUTABLE_NAME, solc_arguments, None);
    assert_evm_blob_from_yul(&solc_result);
}

/// This test mimics the command used in the `resolc` benchmarks when compiling Solidity via standard JSON input.
#[test]
fn compiles_json_to_binary_blob() {
    let path = absolute_path(STANDARD_JSON_CONTRACTS_PATH);
    let resolc_arguments = &["--standard-json"];
    let solc_arguments = &["--standard-json"];

    let resolc_result = execute_command(
        crate::DEFAULT_EXECUTABLE_NAME,
        resolc_arguments,
        Some(&path),
    );
    assert_pvm_blob_from_json(&resolc_result, "src/Counter.sol", "Counter");

    let solc_result = execute_command(
        SolcCompiler::DEFAULT_EXECUTABLE_NAME,
        solc_arguments,
        Some(&path),
    );
    assert_evm_blob_from_json(&solc_result, "src/Counter.sol", "Counter");
}