8#include "crypto/sha256.h"
21 const evmc::uint256be& nonce) -> evmc::address {
22 auto new_addr = evmc::address();
25 auto addr_hash =
keccak_data(buf.data(), buf.size());
26 constexpr auto addr_offset = addr_hash.size() -
sizeof(new_addr.bytes);
27 std::memcpy(new_addr.bytes,
28 addr_hash.data() + addr_offset,
29 sizeof(new_addr.bytes));
34 const evmc::bytes32& salt,
39 auto new_addr = evmc::address();
41 static constexpr uint8_t contract_address2_preimage_prefix = 0xFF;
42 auto b = std::byte(contract_address2_preimage_prefix);
43 buf.append(&b,
sizeof(b));
44 buf.append(sender.bytes,
sizeof(sender.bytes));
45 buf.append(salt.bytes,
sizeof(salt.bytes));
46 buf.append(bytecode_hash.data(), bytecode_hash.size());
48 auto addr_hash =
keccak_data(buf.data(), buf.size());
49 constexpr auto addr_offset = addr_hash.size() -
sizeof(new_addr.bytes);
50 std::memcpy(new_addr.bytes,
51 addr_hash.data() + addr_offset,
52 sizeof(new_addr.bytes));
56 auto eth_addr(
const std::unique_ptr<secp256k1_pubkey>& pk,
57 const std::shared_ptr<secp256k1_context>& ctx)
59 static constexpr int uncompressed_pubkey_len = 65;
60 auto pubkey_serialized
61 = std::array<unsigned char, uncompressed_pubkey_len>();
62 auto pubkey_size = pubkey_serialized.size();
63 [[maybe_unused]]
const auto ser_ret
64 = ::secp256k1_ec_pubkey_serialize(ctx.get(),
65 pubkey_serialized.data(),
68 SECP256K1_EC_UNCOMPRESSED);
72 pubkey_buffer.extend(uncompressed_pubkey_len);
73 std::memcpy(pubkey_buffer.data(),
74 pubkey_serialized.data(),
75 pubkey_serialized.size());
78 uncompressed_pubkey_len - 1);
79 auto addr = evmc::address();
80 constexpr auto addr_offset = addr_hash.size() -
sizeof(addr.bytes);
81 std::memcpy(addr.bytes,
82 addr_hash.data() + addr_offset,
88 const std::shared_ptr<secp256k1_context>& ctx)
90 auto pk = std::make_unique<secp256k1_pubkey>();
91 [[maybe_unused]]
const auto pub_ret
92 = ::secp256k1_ec_pubkey_create(ctx.get(), pk.get(), key.data());
auto eth_addr(const std::unique_ptr< secp256k1_pubkey > &pk, const std::shared_ptr< secp256k1_context > &ctx) -> evmc::address
Calculates an eth address from a public key.
auto contract_address2(const evmc::address &sender, const evmc::bytes32 &salt, const cbdc::hash_t &bytecode_hash) -> evmc::address
Calculates a contract address for the CREATE2 call keccak256(0xFF | sender | salt | keccak256(bytecod...
auto contract_address(const evmc::address &sender, const evmc::uint256be &nonce) -> evmc::address
Calculates a contract address for the CREATE call keccak256(rlp([sender,nonce]))
std::array< unsigned char, cbdc::hash_size > hash_t
SHA256 hash container.
auto make_rlp_value(const T &obj, bool trim_leading_zeroes=false) -> rlp_value
Turns an existing value into an rlp_value by first serializing it as a cbdc::buffer,...
std::array< unsigned char, pubkey_len > privkey_t
A private key of a public/private keypair.
@ buffer
A singular RLP value (byte array)
auto keccak_data(const void *data, size_t len) -> hash_t
Calculates the Keccak256 hash of the specified data.
auto make_buffer(const T &obj) -> std::enable_if_t< std::is_same_v< B, nuraft::ptr< nuraft::buffer > >, nuraft::ptr< nuraft::buffer > >
Serialize object into nuraft::buffer using a cbdc::nuraft_serializer.
auto make_rlp_array(const Args &... values) -> rlp_value
Turns multiple rlp_value objects into an rlp_value of type array.