11 static constexpr unsigned char byte_size_offset = 0x80;
12 static constexpr unsigned char array_size_offset = 0xc0;
13 static constexpr unsigned char max_onebyte_length = 55;
20 if(b < byte_size_offset) {
24 std::memcpy(m_buffer.
data(), &b, 1);
25 }
else if(b >= byte_size_offset
26 && b <= byte_size_offset + max_onebyte_length) {
27 auto read_len =
static_cast<size_t>(b - byte_size_offset);
28 read_buffer_from(ser, read_len);
29 }
else if(b > byte_size_offset + max_onebyte_length
30 && b < array_size_offset) {
32 auto len_len =
static_cast<size_t>(b - byte_size_offset
33 - max_onebyte_length);
36 len_buf.extend(len_len);
37 ser.
read(len_buf.data(), len_len);
40 read_buffer_from(ser, read_len);
41 }
else if(b >= array_size_offset
42 && b <= array_size_offset + max_onebyte_length) {
43 auto array_len =
static_cast<size_t>(b - array_size_offset);
44 read_array_from(ser, array_len);
45 }
else if(b > array_size_offset + max_onebyte_length) {
47 auto len_len =
static_cast<size_t>(b - array_size_offset
48 - max_onebyte_length);
51 len_buf.extend(len_len);
52 ser.
read(len_buf.data(), len_len);
55 read_array_from(ser, array_len);
59 void rlp_value::read_buffer_from(
serializer& ser,
size_t size) {
65 void rlp_value::read_array_from(serializer& ser,
size_t size) {
69 array_buf.extend(
size);
70 ser.read(array_buf.data(),
size);
72 while(!array_deser.end_of_buffer()) {
75 m_values.push_back(v);
82 auto vec = std::vector<uint8_t>();
83 vec.resize(
sizeof(
size_t));
85 std::memcpy(&vec[vec.size() - buf.size()], buf.data(), buf.size());
86 std::reverse(vec.begin(), vec.end());
87 std::memcpy(&ret, vec.data(),
sizeof(
size_t));
93 -> std::optional<parsec::agent::runner::evm_access_list> {
99 for(
size_t i = 0; i < rlp.size(); i++) {
100 auto rlp_tuple = rlp.value_at(i);
104 && rlp_tuple.size() == 2) {
105 access_tuple.m_address
106 = rlp_tuple.value_at(0).value<evmc::address>();
108 auto rlp_storage_keys = rlp_tuple.value_at(1);
109 for(
size_t j = 0; j < rlp_storage_keys.size(); j++) {
110 access_tuple.m_storage_keys.push_back(
111 rlp_storage_keys.value_at(j).value<evmc::bytes32>());
113 access_list.push_back(access_tuple);
Serializer implementation for buffer.
Buffer to store and retrieve byte data.
auto data() -> void *
Returns a raw pointer to the start of the buffer data.
void clear()
Removes any existing content in the buffer making its size 0.
void extend(size_t len)
Extends the size of the buffer by the given length.
This class contains a value that can be serialized into, or was deserialized from,...
auto size() const -> size_t
Get the size of the rlp_value.
rlp_value()
Default constructor. Sets m_type to rlp_value_type::buffer.
void read_from(serializer &ser)
Deserializes the rlp_value in RLP representation from the passed serializer into the current rlp_valu...
Interface for serializing objects into and out of raw bytes representations.
virtual auto read(void *data, size_t len) -> bool=0
Attempts to read the requested number of bytes from the current cursor position into the given memory...
std::vector< evm_access_tuple > evm_access_list
Type alias for a list of storage key accesses.
auto rlp_decode_access_list(const rlp_value &rlp) -> std::optional< parsec::agent::runner::evm_access_list >
Decodes an access list from and rlp_value of type rlp_value_type::array.
auto operator>>(serializer &deser, parsec::agent::rpc::request &req) -> serializer &
@ buffer
A singular RLP value (byte array)
@ array
A collection of RLP values.
auto deserialize_size(const cbdc::buffer &buf) -> size_t
Decodes a binary representation for sizes that exceed the single-byte presentation into size_t.
Type for tracking storage key accesses between accounts.