OpenCBDC Transaction Processor
Loading...
Searching...
No Matches
rlp_reader.cpp
Go to the documentation of this file.
1#include "rlp.hpp"
2
3namespace cbdc {
4
6 v.read_from(ser);
7 return ser;
8 }
9
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;
14 unsigned char b{};
15 ser.read(&b, 1);
16
17 m_buffer.clear();
18 m_values.clear();
19
20 if(b < byte_size_offset) {
22 m_buffer.clear();
23 m_buffer.extend(1);
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) {
31 // First we read the length of the length
32 auto len_len = static_cast<size_t>(b - byte_size_offset
33 - max_onebyte_length);
34 // Then we read the length bytes
35 auto len_buf = cbdc::buffer();
36 len_buf.extend(len_len);
37 ser.read(len_buf.data(), len_len);
38 // Then we turn the read length into a size_t
39 auto read_len = deserialize_size(len_buf);
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) {
46 // First we read the length of the length
47 auto len_len = static_cast<size_t>(b - array_size_offset
48 - max_onebyte_length);
49 // Then we read the length bytes
50 auto len_buf = cbdc::buffer();
51 len_buf.extend(len_len);
52 ser.read(len_buf.data(), len_len);
53 // Then we turn the read length into a size_t
54 auto array_len = deserialize_size(len_buf);
55 read_array_from(ser, array_len);
56 }
57 }
58
59 void rlp_value::read_buffer_from(serializer& ser, size_t size) {
61 m_buffer.extend(size);
62 ser.read(m_buffer.data(), size);
63 }
64
65 void rlp_value::read_array_from(serializer& ser, size_t size) {
66 m_type = rlp_value_type::array;
67 if(size > 0) {
68 auto array_buf = cbdc::buffer();
69 array_buf.extend(size);
70 ser.read(array_buf.data(), size);
71 auto array_deser = cbdc::buffer_serializer(array_buf);
72 while(!array_deser.end_of_buffer()) {
74 array_deser >> v;
75 m_values.push_back(v);
76 }
77 }
78 }
79
80 auto deserialize_size(const cbdc::buffer& buf) -> size_t {
81 size_t ret{0};
82 auto vec = std::vector<uint8_t>();
83 vec.resize(sizeof(size_t));
84
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));
88
89 return ret;
90 }
91
93 -> std::optional<parsec::agent::runner::evm_access_list> {
94 if(rlp.type() != rlp_value_type::array) {
95 return std::nullopt;
96 }
97
99 for(size_t i = 0; i < rlp.size(); i++) {
100 auto rlp_tuple = rlp.value_at(i);
101 auto access_tuple
103 if(rlp_tuple.type() == rlp_value_type::array
104 && rlp_tuple.size() == 2) {
105 access_tuple.m_address
106 = rlp_tuple.value_at(0).value<evmc::address>();
107 }
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>());
112 }
113 access_list.push_back(access_tuple);
114 }
115
116 return access_list;
117 }
118}
Serializer implementation for buffer.
Buffer to store and retrieve byte data.
Definition buffer.hpp:15
auto data() -> void *
Returns a raw pointer to the start of the buffer data.
Definition buffer.cpp:28
void clear()
Removes any existing content in the buffer making its size 0.
Definition buffer.cpp:14
void extend(size_t len)
Extends the size of the buffer by the given length.
Definition buffer.cpp:48
This class contains a value that can be serialized into, or was deserialized from,...
Definition rlp.hpp:32
auto size() const -> size_t
Get the size of the rlp_value.
Definition rlp.cpp:35
rlp_value()
Default constructor. Sets m_type to rlp_value_type::buffer.
Definition rlp.cpp:9
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.