Skip to content

Commit 006cd7b

Browse files
SixtysixterSixtysixter
authored
rpc: In ExecutionResult changed error_code in status_code (#2756)
1 parent 0b6d12c commit 006cd7b

8 files changed

+46
-46
lines changed

‎silkworm/rpc/core/call_many.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -100,7 +100,7 @@ CallManyResult CallExecutor::executes_all_bundles(const silkworm::ChainConfig& c
100100
}
101101

102102
nlohmann::json reply;
103-
if (call_execution_result.error_code == evmc_status_code::EVMC_SUCCESS) {
103+
if (call_execution_result.status_code == evmc_status_code::EVMC_SUCCESS) {
104104
if (rpc::compatibility::is_erigon_json_api_compatibility_required()) {
105105
reply["value"] = silkworm::to_hex(call_execution_result.data);
106106
} else {

‎silkworm/rpc/core/estimate_gas_oracle.cpp

+5-5
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,7 @@ Task<intx::uint256> EstimateGasOracle::estimate_gas(const Call& call, const silk
9898
hi = mid;
9999
} else {
100100
if (result.pre_check_error_code && result.pre_check_error_code != PreCheckErrorCode::kIntrinsicGasTooLow) {
101-
result.error_code = evmc_status_code::EVMC_SUCCESS;
101+
result.status_code = evmc_status_code::EVMC_SUCCESS;
102102
return result;
103103
}
104104
lo = mid;
@@ -110,10 +110,10 @@ Task<intx::uint256> EstimateGasOracle::estimate_gas(const Call& call, const silk
110110
EVMExecutor executor{block, config_, workers_, state_overrides};
111111
transaction.gas_limit = hi;
112112
result = try_execution(executor, transaction);
113-
SILK_DEBUG << "HI == cap tested again with " << (result.error_code == evmc_status_code::EVMC_SUCCESS ? "succeed" : "failed");
113+
SILK_DEBUG << "HI == cap tested again with " << (result.status_code == evmc_status_code::EVMC_SUCCESS ? "succeed" : "failed");
114114
} else if (!result.pre_check_error_code || result.pre_check_error_code == PreCheckErrorCode::kIntrinsicGasTooLow) {
115115
result.pre_check_error = std::nullopt;
116-
result.error_code = evmc_status_code::EVMC_SUCCESS;
116+
result.status_code = evmc_status_code::EVMC_SUCCESS;
117117
}
118118

119119
SILK_DEBUG << "EstimateGasOracle::estimate_gas returns " << hi;
@@ -122,7 +122,7 @@ Task<intx::uint256> EstimateGasOracle::estimate_gas(const Call& call, const silk
122122
});
123123

124124
if (!exec_result.success()) {
125-
if (exec_result.error_code == evmc_status_code::EVMC_OUT_OF_GAS) {
125+
if (exec_result.status_code == evmc_status_code::EVMC_OUT_OF_GAS) {
126126
std::string error_msg = "gas required exceeds allowance (" + std::to_string(hi) + ")";
127127
throw EstimateGasException{-32000, error_msg};
128128
}
@@ -141,7 +141,7 @@ void EstimateGasOracle::throw_exception(ExecutionResult& result) {
141141
throw EstimateGasException{-32000, *result.pre_check_error};
142142
}
143143
auto error_message = result.error_message();
144-
SILK_DEBUG << "result message: " << error_message << ", code " << *result.error_code;
144+
SILK_DEBUG << "result message: " << error_message << ", code " << *result.status_code;
145145
if (result.data.empty()) {
146146
throw EstimateGasException{-32000, error_message};
147147
}

‎silkworm/rpc/core/estimate_gas_oracle_test.cpp

+26-26
Original file line numberDiff line numberDiff line change
@@ -103,8 +103,8 @@ TEST_CASE("estimate gas") {
103103
MockEstimateGasOracle estimate_gas_oracle{block_header_provider, account_reader, config, workers, *tx, storage, accounts_overrides};
104104

105105
SECTION("Call empty, always fails but success in last step") {
106-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
107-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
106+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
107+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
108108
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _))
109109
.Times(16)
110110
.WillOnce(Return(expect_result_fail))
@@ -130,16 +130,16 @@ TEST_CASE("estimate gas") {
130130
}
131131

132132
SECTION("Call empty, always succeeds") {
133-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
133+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
134134
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(14).WillRepeatedly(Return(expect_result_ok));
135135
auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future);
136136
const intx::uint256& estimate_gas = result.get();
137137
CHECK(estimate_gas == kTxGas);
138138
}
139139

140140
SECTION("Call empty, alternatively fails and succeeds") {
141-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
142-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
141+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
142+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
143143
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _))
144144
.Times(14)
145145
.WillOnce(Return(expect_result_fail))
@@ -163,8 +163,8 @@ TEST_CASE("estimate gas") {
163163
}
164164

165165
SECTION("Call empty, alternatively succeeds and fails") {
166-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
167-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
166+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
167+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
168168
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _))
169169
.Times(14)
170170
.WillOnce(Return(expect_result_ok))
@@ -188,11 +188,11 @@ TEST_CASE("estimate gas") {
188188
}
189189

190190
SECTION("Call empty, alternatively succeeds and fails with intrinsic") {
191-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
191+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
192192
ExecutionResult expect_result_fail_pre_check{
193193
.pre_check_error = "intrinsic ",
194194
.pre_check_error_code = PreCheckErrorCode::kIntrinsicGasTooLow};
195-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
195+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
196196
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _))
197197
.Times(14)
198198
.WillOnce(Return(expect_result_ok))
@@ -217,8 +217,8 @@ TEST_CASE("estimate gas") {
217217

218218
SECTION("Call with gas, always fails but succes last step") {
219219
call.gas = kTxGas * 4;
220-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
221-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
220+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
221+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
222222
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _))
223223
.Times(17)
224224
.WillOnce(Return(expect_result_fail))
@@ -246,7 +246,7 @@ TEST_CASE("estimate gas") {
246246

247247
SECTION("Call with gas, always succeeds") {
248248
call.gas = kTxGas * 4;
249-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
249+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
250250
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _))
251251
.Times(15)
252252
.WillRepeatedly(Return(expect_result_ok));
@@ -257,8 +257,8 @@ TEST_CASE("estimate gas") {
257257
}
258258

259259
SECTION("Call with gas_price, gas not capped") {
260-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
261-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
260+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
261+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
262262
call.gas = kTxGas * 2;
263263
call.gas_price = intx::uint256{10'000};
264264

@@ -287,8 +287,8 @@ TEST_CASE("estimate gas") {
287287
}
288288

289289
SECTION("Call with gas_price, gas capped") {
290-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
291-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
290+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
291+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
292292
call.gas = kTxGas * 2;
293293
call.gas_price = intx::uint256{40'000};
294294

@@ -314,8 +314,8 @@ TEST_CASE("estimate gas") {
314314
}
315315

316316
SECTION("Call with gas_price and value, gas not capped") {
317-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
318-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
317+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
318+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
319319
call.gas = kTxGas * 2;
320320
call.gas_price = intx::uint256{10'000};
321321
call.value = intx::uint256{500'000'000};
@@ -345,8 +345,8 @@ TEST_CASE("estimate gas") {
345345
}
346346

347347
SECTION("Call with gas_price and value, gas capped") {
348-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
349-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
348+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
349+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
350350
call.gas = kTxGas * 2;
351351
call.gas_price = intx::uint256{20'000};
352352
call.value = intx::uint256{500'000'000};
@@ -373,7 +373,7 @@ TEST_CASE("estimate gas") {
373373
}
374374

375375
SECTION("Call gas above allowance, always succeeds, gas capped") {
376-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
376+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
377377
call.gas = kGasCap * 2;
378378
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(25).WillRepeatedly(Return(expect_result_ok));
379379
auto result = boost::asio::co_spawn(pool, estimate_gas_oracle.estimate_gas(call, block, 244087591818874), boost::asio::use_future);
@@ -383,7 +383,7 @@ TEST_CASE("estimate gas") {
383383
}
384384

385385
SECTION("Call gas below minimum, always succeeds") {
386-
ExecutionResult expect_result_ok{.error_code = evmc_status_code::EVMC_SUCCESS};
386+
ExecutionResult expect_result_ok{.status_code = evmc_status_code::EVMC_SUCCESS};
387387
call.gas = kTxGas / 2;
388388

389389
EXPECT_CALL(estimate_gas_oracle, try_execution(_, _)).Times(14).WillRepeatedly(Return(expect_result_ok));
@@ -394,7 +394,7 @@ TEST_CASE("estimate gas") {
394394
}
395395

396396
SECTION("Call with too high value, exception") {
397-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
397+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
398398
call.value = intx::uint256{2'000'000'000};
399399

400400
try {
@@ -415,7 +415,7 @@ TEST_CASE("estimate gas") {
415415
ExecutionResult expect_result_fail_pre_check{
416416
.pre_check_error = "insufficient funds",
417417
.pre_check_error_code = PreCheckErrorCode::kInsufficientFunds};
418-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS};
418+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS};
419419
call.gas = kTxGas * 2;
420420
call.gas_price = intx::uint256{20'000};
421421
call.value = intx::uint256{500'000'000};
@@ -442,7 +442,7 @@ TEST_CASE("estimate gas") {
442442
ExecutionResult expect_result_fail_pre_check{
443443
.pre_check_error = "insufficient funds",
444444
.pre_check_error_code = PreCheckErrorCode::kInsufficientFunds};
445-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_OUT_OF_GAS, .data = data};
445+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_OUT_OF_GAS, .data = data};
446446
call.gas = kTxGas * 2;
447447
call.gas_price = intx::uint256{20'000};
448448
call.value = intx::uint256{500'000'000};
@@ -468,7 +468,7 @@ TEST_CASE("estimate gas") {
468468
ExecutionResult expect_result_fail_pre_check{
469469
.pre_check_error = "insufficient funds",
470470
.pre_check_error_code = PreCheckErrorCode::kInsufficientFunds};
471-
ExecutionResult expect_result_fail{.error_code = evmc_status_code::EVMC_INVALID_INSTRUCTION};
471+
ExecutionResult expect_result_fail{.status_code = evmc_status_code::EVMC_INVALID_INSTRUCTION};
472472
call.gas = kTxGas * 2;
473473
call.gas_price = intx::uint256{20'000};
474474
call.value = intx::uint256{500'000'000};

‎silkworm/rpc/core/evm_debug.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -559,13 +559,13 @@ Task<void> DebugExecutor::execute(
559559
debug_tracer->flush_logs();
560560
stream.close_array();
561561

562-
SILK_DEBUG << "result error_code: " << execution_result.error_code.value_or(0) << ", message: " << execution_result.error_message();
562+
SILK_DEBUG << "result error_code: " << execution_result.status_code.value_or(evmc_status_code::EVMC_SUCCESS) << ", message: " << execution_result.error_message();
563563

564564
if (!execution_result.pre_check_error) {
565565
stream.write_json_field("failed", !execution_result.success());
566566
stream.write_field("gas", transaction.gas_limit - execution_result.gas_left);
567-
const auto error_code = execution_result.error_code.value_or(evmc_status_code::EVMC_SUCCESS);
568-
if (error_code == evmc_status_code::EVMC_SUCCESS || error_code == evmc_status_code::EVMC_REVERT) {
567+
const auto status_code = execution_result.status_code.value_or(evmc_status_code::EVMC_SUCCESS);
568+
if (status_code == evmc_status_code::EVMC_SUCCESS || status_code == evmc_status_code::EVMC_REVERT) {
569569
stream.write_field("returnValue", silkworm::to_hex(execution_result.data));
570570
} else {
571571
stream.write_field("returnValue", "");

‎silkworm/rpc/core/evm_executor.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -41,8 +41,8 @@ std::string ExecutionResult::error_message(bool full_error) const {
4141
if (pre_check_error) {
4242
return *pre_check_error;
4343
}
44-
if (error_code) {
45-
return silkworm::rpc::EVMExecutor::get_error_message(*error_code, data, full_error);
44+
if (status_code) {
45+
return silkworm::rpc::EVMExecutor::get_error_message(*status_code, data, full_error);
4646
}
4747
return "";
4848
}

‎silkworm/rpc/core/evm_executor.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -50,14 +50,14 @@ enum class PreCheckErrorCode {
5050
};
5151

5252
struct ExecutionResult {
53-
std::optional<int64_t> error_code;
53+
std::optional<evmc_status_code> status_code;
5454
uint64_t gas_left{0};
5555
Bytes data;
5656
std::optional<std::string> pre_check_error{std::nullopt};
5757
std::optional<PreCheckErrorCode> pre_check_error_code{std::nullopt};
5858

5959
bool success() const {
60-
return ((error_code == std::nullopt || *error_code == evmc_status_code::EVMC_SUCCESS) && pre_check_error == std::nullopt);
60+
return ((status_code == std::nullopt || *status_code == evmc_status_code::EVMC_SUCCESS) && pre_check_error == std::nullopt);
6161
}
6262

6363
std::string error_message(bool full_error = true) const;

‎silkworm/rpc/core/evm_executor_test.cpp

+6-6
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,7 @@ TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") {
7474

7575
EVMExecutor executor{block, *chain_config_ptr, workers, state};
7676
const auto result = executor.call(txn, {});
77-
CHECK(result.error_code == std::nullopt);
77+
CHECK(result.status_code == std::nullopt);
7878
CHECK(result.pre_check_error.value() == "intrinsic gas too low: have 0, want 53000");
7979
}
8080

@@ -89,7 +89,7 @@ TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") {
8989

9090
EVMExecutor executor{block, *chain_config_ptr, workers, state};
9191
const auto result = executor.call(txn, {});
92-
CHECK(result.error_code == std::nullopt);
92+
CHECK(result.status_code == std::nullopt);
9393
CHECK(result.pre_check_error.value() == "fee cap less than block base fee: address 0xa872626373628737383927236382161739290870, gasFeeCap: 2 baseFee: 7");
9494
}
9595

@@ -105,7 +105,7 @@ TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") {
105105

106106
EVMExecutor executor{block, *chain_config_ptr, workers, state};
107107
const auto result = executor.call(txn, {});
108-
CHECK(result.error_code == std::nullopt);
108+
CHECK(result.status_code == std::nullopt);
109109
CHECK(result.pre_check_error.value() == "tip higher than fee cap: address 0xa872626373628737383927236382161739290870, tip: 24 gasFeeCap: 2");
110110
}
111111

@@ -128,7 +128,7 @@ TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") {
128128

129129
EVMExecutor executor{block, *chain_config_ptr, workers, state};
130130
const auto result = executor.call(txn, {});
131-
CHECK(result.error_code == std::nullopt);
131+
CHECK(result.status_code == std::nullopt);
132132
CHECK(result.pre_check_error.value() == "insufficient funds for gas * price + value: address 0xa872626373628737383927236382161739290870 have 0 want 60000");
133133
}
134134

@@ -152,7 +152,7 @@ TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") {
152152
EVMExecutor executor{block, *chain_config_ptr, workers, state};
153153
const auto result = executor.call(txn, {}, false, /* gasBailout */ true);
154154
executor.reset();
155-
CHECK(result.error_code == 0);
155+
CHECK(result.status_code == evmc_status_code::EVMC_SUCCESS);
156156
}
157157

158158
AccessList access_list{
@@ -182,7 +182,7 @@ TEST_CASE_METHOD(EVMExecutorTest, "EVMExecutor") {
182182

183183
EVMExecutor executor{block, *chain_config_ptr, workers, state};
184184
const auto result = executor.call(txn, {}, true, /* gasBailout */ true);
185-
CHECK(result.error_code == 0);
185+
CHECK(result.status_code == 0);
186186
}
187187

188188
static silkworm::Bytes error_data{

‎silkworm/rpc/core/evm_trace.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -1678,7 +1678,7 @@ Task<std::string> TraceCallExecutor::trace_transaction_error(const TransactionWi
16781678
auto execution_result = executor.call(txn, {}, /*refund=*/true, /*gas_bailout=*/false);
16791679

16801680
std::string result = "0x";
1681-
if (execution_result.error_code != evmc_status_code::EVMC_SUCCESS) {
1681+
if (execution_result.status_code != evmc_status_code::EVMC_SUCCESS) {
16821682
result = "0x" + silkworm::to_hex(execution_result.data);
16831683
}
16841684
return result;

0 commit comments

Comments
 (0)