Skip to content

Commit e90e137

Browse files
dhildhil
committed
Semantic state override object
1 parent 08b0345 commit e90e137

File tree

1 file changed

+50
-59
lines changed

1 file changed

+50
-59
lines changed

‎category/rpc/monad_executor.cpp‎

Lines changed: 50 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919
#include <category/core/byte_string.hpp>
2020
#include <category/core/bytes.hpp>
2121
#include <category/core/fiber/priority_pool.hpp>
22+
#include <category/core/int.hpp>
2223
#include <category/core/keccak.hpp>
2324
#include <category/core/likely.h>
2425
#include <category/core/lru/static_lru_cache.hpp>
@@ -71,7 +72,6 @@
7172
#include <cstring>
7273
#include <filesystem>
7374
#include <format>
74-
#include <map>
7575
#include <memory>
7676
#include <optional>
7777
#include <span>
@@ -98,14 +98,16 @@ struct monad_state_override
9898
{
9999
struct monad_state_override_object
100100
{
101-
std::optional<byte_string> balance{std::nullopt};
101+
std::optional<uint256_t> balance{std::nullopt};
102102
std::optional<uint64_t> nonce{std::nullopt};
103103
std::optional<byte_string> code{std::nullopt};
104-
std::map<byte_string, byte_string> state{};
105-
std::map<byte_string, byte_string> state_diff{};
104+
ankerl::unordered_dense::segmented_map<bytes32_t, bytes32_t> state{};
105+
ankerl::unordered_dense::segmented_map<bytes32_t, bytes32_t>
106+
state_diff{};
106107
};
107108

108-
std::map<byte_string, monad_state_override_object> override_sets;
109+
ankerl::unordered_dense::segmented_map<Address, monad_state_override_object>
110+
override_sets;
109111
};
110112

111113
namespace
@@ -201,12 +203,11 @@ namespace
201203
enriched_txn.sc.r = 1;
202204
enriched_txn.sc.s = 1;
203205

204-
BOOST_OUTCOME_TRY(
205-
static_validate_transaction<traits>(
206-
enriched_txn,
207-
header.base_fee_per_gas,
208-
header.excess_blob_gas,
209-
chain.get_chain_id()));
206+
BOOST_OUTCOME_TRY(static_validate_transaction<traits>(
207+
enriched_txn,
208+
header.base_fee_per_gas,
209+
header.excess_blob_gas,
210+
chain.get_chain_id()));
210211

211212
tdb.set_block_and_prefix(block_number, block_id);
212213
BlockState block_state{tdb, vm};
@@ -215,12 +216,8 @@ namespace
215216
{
216217
State state{block_state, incarnation};
217218

218-
for (auto const &[addr, state_delta] :
219+
for (auto const &[address, state_delta] :
219220
state_overrides.override_sets) {
220-
// address
221-
Address address{};
222-
std::memcpy(address.bytes, addr.data(), sizeof(Address));
223-
224221
// This would avoid seg-fault on storage override for
225222
// non-existing accounts
226223
auto const &account = state.recent_account(address);
@@ -229,24 +226,16 @@ namespace
229226
}
230227

231228
if (state_delta.balance.has_value()) {
232-
auto const balance = intx::be::unsafe::load<uint256_t>(
233-
state_delta.balance.value().data());
234-
if (balance >
235-
intx::be::load<uint256_t>(
236-
state.get_current_balance_pessimistic(address))) {
229+
auto const balance = state_delta.balance.value();
230+
auto const pessimistic_balance = intx::be::load<uint256_t>(
231+
state.get_current_balance_pessimistic(address));
232+
if (balance > pessimistic_balance) {
237233
state.add_to_balance(
238-
address,
239-
balance - intx::be::load<uint256_t>(
240-
state.get_current_balance_pessimistic(
241-
address)));
234+
address, balance - pessimistic_balance);
242235
}
243236
else {
244237
state.subtract_from_balance(
245-
address,
246-
intx::be::load<uint256_t>(
247-
state.get_current_balance_pessimistic(
248-
address)) -
249-
balance);
238+
address, pessimistic_balance - balance);
250239
}
251240
}
252241

@@ -255,28 +244,15 @@ namespace
255244
}
256245

257246
if (state_delta.code.has_value()) {
258-
byte_string const code{
259-
state_delta.code.value().data(),
260-
state_delta.code.value().size()};
261-
state.set_code(address, code);
247+
state.set_code(address, state_delta.code.value());
262248
}
263249

264250
auto const update_state =
265-
[&](std::map<byte_string, byte_string> const &diff) {
251+
[&address = address, &state = state](
252+
ankerl::unordered_dense::
253+
segmented_map<bytes32_t, bytes32_t> const &diff) {
266254
for (auto const &[key, value] : diff) {
267-
bytes32_t storage_key;
268-
bytes32_t storage_value;
269-
std::memcpy(
270-
storage_key.bytes,
271-
key.data(),
272-
sizeof(bytes32_t));
273-
std::memcpy(
274-
storage_value.bytes,
275-
value.data(),
276-
sizeof(bytes32_t));
277-
278-
state.set_storage(
279-
address, storage_key, storage_value);
255+
state.set_storage(address, key, value);
280256
}
281257
};
282258

@@ -583,7 +559,8 @@ void add_override_address(
583559

584560
MONAD_ASSERT(addr);
585561
MONAD_ASSERT(addr_len == sizeof(Address));
586-
byte_string const address{addr, addr + addr_len};
562+
Address address;
563+
std::memcpy(address.bytes, addr, sizeof(Address));
587564

588565
MONAD_ASSERT(m->override_sets.find(address) == m->override_sets.end());
589566
m->override_sets.emplace(address, StateOverrideObj{});
@@ -598,12 +575,14 @@ void set_override_balance(
598575

599576
MONAD_ASSERT(addr);
600577
MONAD_ASSERT(addr_len == sizeof(Address));
601-
byte_string const address{addr, addr + addr_len};
578+
Address address;
579+
std::memcpy(address.bytes, addr, sizeof(Address));
602580
MONAD_ASSERT(m->override_sets.find(address) != m->override_sets.end());
603581

604582
MONAD_ASSERT(balance);
605583
MONAD_ASSERT(balance_len == sizeof(uint256_t));
606-
m->override_sets[address].balance = {balance, balance + balance_len};
584+
m->override_sets[address].balance =
585+
intx::be::unsafe::load<uint256_t>(balance);
607586
}
608587

609588
void set_override_nonce(
@@ -614,7 +593,8 @@ void set_override_nonce(
614593

615594
MONAD_ASSERT(addr);
616595
MONAD_ASSERT(addr_len == sizeof(Address));
617-
byte_string const address{addr, addr + addr_len};
596+
Address address;
597+
std::memcpy(address.bytes, addr, sizeof(Address));
618598
MONAD_ASSERT(m->override_sets.find(address) != m->override_sets.end());
619599

620600
m->override_sets[address].nonce = nonce;
@@ -628,7 +608,8 @@ void set_override_code(
628608

629609
MONAD_ASSERT(addr);
630610
MONAD_ASSERT(addr_len == sizeof(Address));
631-
byte_string const address{addr, addr + addr_len};
611+
Address address;
612+
std::memcpy(address.bytes, addr, sizeof(Address));
632613
MONAD_ASSERT(m->override_sets.find(address) != m->override_sets.end());
633614

634615
MONAD_ASSERT(code);
@@ -644,18 +625,23 @@ void set_override_state_diff(
644625

645626
MONAD_ASSERT(addr);
646627
MONAD_ASSERT(addr_len == sizeof(Address));
647-
byte_string const address{addr, addr + addr_len};
628+
Address address;
629+
std::memcpy(address.bytes, addr, sizeof(Address));
648630
MONAD_ASSERT(m->override_sets.find(address) != m->override_sets.end());
649631

650632
MONAD_ASSERT(key);
651633
MONAD_ASSERT(key_len == sizeof(bytes32_t));
652-
byte_string const k{key, key + key_len};
634+
bytes32_t k;
635+
std::memcpy(k.bytes, key, sizeof(bytes32_t));
653636

654637
MONAD_ASSERT(value);
638+
MONAD_ASSERT(value_len == sizeof(bytes32_t));
639+
bytes32_t v;
640+
std::memcpy(v.bytes, value, sizeof(bytes32_t));
655641

656642
auto &state_object = m->override_sets[address].state_diff;
657643
MONAD_ASSERT(state_object.find(k) == state_object.end());
658-
state_object.emplace(k, byte_string{value, value + value_len});
644+
state_object.emplace(k, v);
659645
}
660646

661647
void set_override_state(
@@ -667,18 +653,23 @@ void set_override_state(
667653

668654
MONAD_ASSERT(addr);
669655
MONAD_ASSERT(addr_len == sizeof(Address));
670-
byte_string const address{addr, addr + addr_len};
656+
Address address;
657+
std::memcpy(address.bytes, addr, sizeof(Address));
671658
MONAD_ASSERT(m->override_sets.find(address) != m->override_sets.end());
672659

673660
MONAD_ASSERT(key);
674661
MONAD_ASSERT(key_len == sizeof(bytes32_t));
675-
byte_string const k{key, key + key_len};
662+
bytes32_t k;
663+
std::memcpy(k.bytes, key, sizeof(bytes32_t));
676664

677665
MONAD_ASSERT(value);
666+
MONAD_ASSERT(value_len == sizeof(bytes32_t));
667+
bytes32_t v;
668+
std::memcpy(v.bytes, value, sizeof(bytes32_t));
678669

679670
auto &state_object = m->override_sets[address].state;
680671
MONAD_ASSERT(state_object.find(k) == state_object.end());
681-
state_object.emplace(k, byte_string{value, value + value_len});
672+
state_object.emplace(k, v);
682673
}
683674

684675
void monad_executor_result_release(monad_executor_result *const result)

0 commit comments

Comments
 (0)