mirror of
https://github.com/oxen-io/oxen-core.git
synced 2023-12-14 02:22:56 +01:00
Store base64 hashes into the LNS DB
Everywhere still uses crypto::hash for the name_hash due to being the most compact storage form except for the LNS DB which uses base64 so that it can be indexes in SQL for speed. But at the boundary between requesting and accessing the DB entry, the hash gets converted into a base64 representation of the hash. We opt for base64 as it is more compact than storing the hex representation.
This commit is contained in:
Doyle
parent
ecf212dbf5
commit
0d4c446d69
5 changed files with 72 additions and 50 deletions
|
|
@ -11,6 +11,7 @@
|
|||
#include "cryptonote_basic/tx_extra.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "loki_economy.h"
|
||||
#include "string_coding.h"
|
||||
|
||||
#include <lokimq/hex.h>
|
||||
|
||||
|
|
@ -155,8 +156,12 @@ static bool sql_run_statement(cryptonote::network_type nettype, lns_sql_type typ
|
|||
memcpy(&tmp_entry.encrypted_value.buffer[0], value, value_len);
|
||||
}
|
||||
|
||||
if (!sql_copy_blob(statement, static_cast<int>(mapping_record_row::name_hash), tmp_entry.name_hash.data, sizeof(tmp_entry.name_hash)))
|
||||
return false;
|
||||
// Copy name hash
|
||||
{
|
||||
size_t value_len = static_cast<size_t>(sqlite3_column_bytes(statement, static_cast<int>(mapping_record_row::name_hash)));
|
||||
auto *value = reinterpret_cast<char const *>(sqlite3_column_text(statement, static_cast<int>(mapping_record_row::name_hash)));
|
||||
tmp_entry.name_hash.append(value, value_len);
|
||||
}
|
||||
|
||||
if (!sql_copy_blob(statement, static_cast<int>(mapping_record_row::txid), tmp_entry.txid.data, sizeof(tmp_entry.txid)))
|
||||
return false;
|
||||
|
|
@ -589,11 +594,18 @@ static std::ostream &operator<<(std::ostream &stream, cryptonote::tx_extra_loki_
|
|||
return stream;
|
||||
}
|
||||
|
||||
static std::string hash_to_base64(crypto::hash const &hash)
|
||||
{
|
||||
std::string result = epee::string_encoding::base64_encode(reinterpret_cast<unsigned char const *>(hash.data), sizeof(hash));
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool validate_against_previous_mapping(lns::name_system_db const &lns_db, uint64_t blockchain_height, cryptonote::transaction const &tx, cryptonote::tx_extra_loki_name_system &data, std::string *reason = nullptr)
|
||||
{
|
||||
std::stringstream err_stream;
|
||||
crypto::hash expected_prev_txid = crypto::null_hash;
|
||||
lns::mapping_record mapping = lns_db.get_mapping(data.type, data.name_hash);
|
||||
std::string name_hash = hash_to_base64(data.name_hash);
|
||||
lns::mapping_record mapping = lns_db.get_mapping(data.type, name_hash);
|
||||
const bool updating = data.command == lns::tx_command_t::update;
|
||||
if (updating && !mapping)
|
||||
{
|
||||
|
|
@ -844,6 +856,13 @@ crypto::hash name_to_hash(std::string const &name)
|
|||
return result;
|
||||
}
|
||||
|
||||
std::string name_to_base64_hash(std::string const &name)
|
||||
{
|
||||
crypto::hash hash = name_to_hash(name);
|
||||
std::string result = hash_to_base64(hash);
|
||||
return result;
|
||||
}
|
||||
|
||||
struct alignas(size_t) secretbox_secret_key_ { unsigned char data[crypto_secretbox_KEYBYTES]; };
|
||||
using secretbox_secret_key = epee::mlocked<tools::scrubbed<secretbox_secret_key_>>;
|
||||
|
||||
|
|
@ -916,7 +935,7 @@ CREATE TABLE IF NOT EXISTS "settings" (
|
|||
CREATE TABLE IF NOT EXISTS "mappings" (
|
||||
"id" INTEGER PRIMARY KEY NOT NULL,
|
||||
"type" INTEGER NOT NULL,
|
||||
"name_hash" BLOB NOT NULL,
|
||||
"name_hash" VARCHAR NOT NULL,
|
||||
"encrypted_value" BLOB NOT NULL,
|
||||
"txid" BLOB NOT NULL,
|
||||
"prev_txid" BLOB NOT NULL,
|
||||
|
|
@ -1221,9 +1240,10 @@ bool name_system_db::save_owner(crypto::ed25519_public_key const &key, int64_t *
|
|||
|
||||
bool name_system_db::save_mapping(crypto::hash const &tx_hash, cryptonote::tx_extra_loki_name_system const &src, uint64_t height, int64_t owner_id)
|
||||
{
|
||||
std::string name_hash = hash_to_base64(src.name_hash);
|
||||
sqlite3_stmt *statement = save_mapping_sql;
|
||||
sqlite3_bind_int (statement, static_cast<int>(mapping_record_row::type), static_cast<uint16_t>(src.type));
|
||||
sqlite3_bind_blob (statement, static_cast<int>(mapping_record_row::name_hash), src.name_hash.data, sizeof(src.name_hash), nullptr /*destructor*/);
|
||||
sqlite3_bind_text (statement, static_cast<int>(mapping_record_row::name_hash), name_hash.data(), name_hash.size(), nullptr /*destructor*/);
|
||||
sqlite3_bind_blob (statement, static_cast<int>(mapping_record_row::encrypted_value), src.encrypted_value.data(), src.encrypted_value.size(), nullptr /*destructor*/);
|
||||
sqlite3_bind_blob (statement, static_cast<int>(mapping_record_row::txid), tx_hash.data, sizeof(tx_hash), nullptr /*destructor*/);
|
||||
sqlite3_bind_blob (statement, static_cast<int>(mapping_record_row::prev_txid), src.prev_txid.data, sizeof(src.prev_txid), nullptr /*destructor*/);
|
||||
|
|
@ -1281,19 +1301,19 @@ owner_record name_system_db::get_owner_by_id(int64_t owner_id) const
|
|||
return result;
|
||||
}
|
||||
|
||||
mapping_record name_system_db::get_mapping(mapping_type type, crypto::hash const &name_hash) const
|
||||
mapping_record name_system_db::get_mapping(mapping_type type, std::string const &name_base64_hash) const
|
||||
{
|
||||
sqlite3_stmt *statement = get_mapping_sql;
|
||||
sqlite3_clear_bindings(statement);
|
||||
sqlite3_bind_int(statement, 1 /*sql param index*/, static_cast<uint16_t>(type));
|
||||
sqlite3_bind_blob(statement, 2 /*sql param index*/, name_hash.data, sizeof(name_hash), nullptr /*destructor*/);
|
||||
sqlite3_bind_text(statement, 2 /*sql param index*/, name_base64_hash.data(), name_base64_hash.size(), nullptr /*destructor*/);
|
||||
|
||||
mapping_record result = {};
|
||||
result.loaded = sql_run_statement(nettype, lns_sql_type::get_mapping, statement, &result);
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<mapping_record> name_system_db::get_mappings(std::vector<uint16_t> const &types, crypto::hash const &name_hash) const
|
||||
std::vector<mapping_record> name_system_db::get_mappings(std::vector<uint16_t> const &types, std::string const &name_base64_hash) const
|
||||
{
|
||||
std::string sql_statement;
|
||||
// Generate string statement
|
||||
|
|
@ -1326,7 +1346,7 @@ std::vector<mapping_record> name_system_db::get_mappings(std::vector<uint16_t> c
|
|||
|
||||
// Bind parameters statements
|
||||
int sql_param_index = 1;
|
||||
sqlite3_bind_blob(statement, sql_param_index++, name_hash.data, sizeof(name_hash), nullptr /*destructor*/);
|
||||
sqlite3_bind_text(statement, sql_param_index++, name_base64_hash.data(), name_base64_hash.size(), nullptr /*destructor*/);
|
||||
for (auto type : types)
|
||||
sqlite3_bind_int(statement, sql_param_index++, type);
|
||||
assert((sql_param_index - 1) == static_cast<int>(1 /*name*/ + types.size()));
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ crypto::hash tx_extra_signature_hash(epee::span<const uint8_t> blob, crypto::has
|
|||
bool validate_lns_name(mapping_type type, std::string const &name, std::string *reason = nullptr);
|
||||
|
||||
// Validate a human readable mapping value representation in 'value' and write the binary form into 'blob'.
|
||||
// value: if type is session, 64 character hex string of an ed25519 public key
|
||||
// value: if type is session, 66 character hex string of an ed25519 public key
|
||||
// lokinet, 52 character base32z string of an ed25519 public key
|
||||
// wallet, the wallet public address string
|
||||
// blob: (optional) if function returns true, validate_mapping_value will convert the 'value' into a binary format suitable for encryption in encrypt_mapping_value(...)
|
||||
|
|
@ -81,8 +81,8 @@ bool validate_encrypted_mapping_value(mapping_type type, std::string con
|
|||
// mapping_type: (optional) if function returns true, the uint16_t value of the 'type' will be set
|
||||
bool validate_mapping_type(std::string const &type, mapping_type *mapping_type, std::string *reason);
|
||||
|
||||
// Takes a human readable mapping name and converts to a hash suitable for storing into the LNS DB.
|
||||
crypto::hash name_to_hash(std::string const &name);
|
||||
crypto::hash name_to_hash(std::string const &name); // Takes a human readable name and hashes it.
|
||||
std::string name_to_base64_hash(std::string const &name); // Takes a human readable name, hashes it and returns a base64 representation of the hash, suitable for storage into the LNS DB.
|
||||
|
||||
// Takes a binary value and encrypts it using 'name' as a secret key or vice versa, suitable for storing into the LNS DB.
|
||||
// Only basic overflow validation is attempted, values should be pre-validated in the validate* functions.
|
||||
|
|
@ -120,7 +120,7 @@ struct mapping_record
|
|||
|
||||
bool loaded;
|
||||
mapping_type type;
|
||||
crypto::hash name_hash;
|
||||
std::string name_hash; // name hashed and represented in base64 encoding
|
||||
mapping_value encrypted_value;
|
||||
uint64_t register_height;
|
||||
int64_t owner_id;
|
||||
|
|
@ -149,8 +149,8 @@ struct name_system_db
|
|||
|
||||
owner_record get_owner_by_key (crypto::ed25519_public_key const &key) const;
|
||||
owner_record get_owner_by_id (int64_t owner_id) const;
|
||||
mapping_record get_mapping (mapping_type type, crypto::hash const &name_hash) const;
|
||||
std::vector<mapping_record> get_mappings (std::vector<uint16_t> const &types, crypto::hash const &name) const;
|
||||
mapping_record get_mapping (mapping_type type, std::string const &name_base64_hash) const;
|
||||
std::vector<mapping_record> get_mappings (std::vector<uint16_t> const &types, std::string const &name_base64_hash) const;
|
||||
std::vector<mapping_record> get_mappings_by_owner (crypto::ed25519_public_key const &key) const;
|
||||
std::vector<mapping_record> get_mappings_by_owners(std::vector<crypto::ed25519_public_key> const &keys) const;
|
||||
settings_record get_settings () const;
|
||||
|
|
|
|||
|
|
@ -3386,7 +3386,7 @@ namespace cryptonote
|
|||
if (exceeds_quantity_limit(ctx, error_resp, m_restricted, request.types.size(), COMMAND_RPC_GET_LNS_NAMES_TO_OWNERS::MAX_TYPE_REQUEST_ENTRIES, "types"))
|
||||
return false;
|
||||
|
||||
crypto::hash name_hash = lns::name_to_hash(request.name);
|
||||
std::string name_hash = lns::name_to_base64_hash(request.name);
|
||||
std::vector<lns::mapping_record> records = db.get_mappings(request.types, name_hash);
|
||||
res.entries.reserve(records.size());
|
||||
for (auto const &record : records)
|
||||
|
|
@ -3433,7 +3433,7 @@ namespace cryptonote
|
|||
|
||||
lns::name_system_db const &db = m_core.get_blockchain_storage().name_system_db();
|
||||
std::vector<lns::mapping_record> records = db.get_mappings_by_owners(keys);
|
||||
for (auto const &record : records)
|
||||
for (auto &record : records)
|
||||
{
|
||||
res.entries.emplace_back();
|
||||
COMMAND_RPC_GET_LNS_OWNERS_TO_NAMES::response_entry &entry = res.entries.back();
|
||||
|
|
@ -3448,7 +3448,7 @@ namespace cryptonote
|
|||
|
||||
entry.request_index = it->second;
|
||||
entry.type = static_cast<uint16_t>(record.type);
|
||||
entry.name_hash = epee::string_tools::pod_to_hex(record.name_hash);
|
||||
entry.name_hash = std::move(record.name_hash);
|
||||
entry.encrypted_value = epee::to_hex::string(epee::span<const uint8_t>(record.encrypted_value.buffer.data(), record.encrypted_value.len));
|
||||
entry.register_height = record.register_height;
|
||||
entry.txid = epee::string_tools::pod_to_hex(record.txid);
|
||||
|
|
|
|||
|
|
@ -537,9 +537,10 @@ cryptonote::transaction loki_chain_generator::create_loki_name_system_tx(crypton
|
|||
if (burn == LNS_AUTO_BURN)
|
||||
burn = lns::burn_needed(new_hf_version, type);
|
||||
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
std::string name_base64_hash = lns::name_to_base64_hash(name);
|
||||
crypto::hash prev_txid = crypto::null_hash;
|
||||
if (lns::mapping_record mapping = lns_db_.get_mapping(type, name_hash))
|
||||
if (lns::mapping_record mapping = lns_db_.get_mapping(type, name_base64_hash))
|
||||
prev_txid = mapping.txid;
|
||||
|
||||
lns::mapping_value encrypted_value = {};
|
||||
|
|
@ -567,9 +568,10 @@ cryptonote::transaction loki_chain_generator::create_loki_name_system_tx_update(
|
|||
crypto::ed25519_signature *signature,
|
||||
bool use_asserts) const
|
||||
{
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
lns::mapping_record mapping = lns_db_.get_mapping(type, name_hash);
|
||||
crypto::hash prev_txid = mapping.txid;
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
std::string name_base64_hash = lns::name_to_base64_hash(name);
|
||||
lns::mapping_record mapping = lns_db_.get_mapping(type, name_base64_hash);
|
||||
crypto::hash prev_txid = mapping.txid;
|
||||
if (use_asserts) assert(mapping);
|
||||
|
||||
crypto::ed25519_public_key pkey;
|
||||
|
|
|
|||
|
|
@ -1069,7 +1069,7 @@ bool loki_name_system_expiration::generate(std::vector<test_event_entry> &events
|
|||
|
||||
uint64_t height_of_lns_entry = gen.height();
|
||||
uint64_t expected_expiry_block = height_of_lns_entry + lns::expiry_blocks(cryptonote::FAKECHAIN, mapping_type, nullptr);
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
std::string name_hash = lns::name_to_base64_hash(name);
|
||||
|
||||
loki_register_callback(events, "check_lns_entries", [=](cryptonote::core &c, size_t ev_index)
|
||||
{
|
||||
|
|
@ -1195,8 +1195,8 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
|
|||
|
||||
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::session))
|
||||
{
|
||||
CHECK_EQ(records[0].name_hash, lns::name_to_hash(session_name1));
|
||||
CHECK_EQ(records[1].name_hash, lns::name_to_hash(session_name2));
|
||||
CHECK_EQ(records[0].name_hash, lns::name_to_base64_hash(session_name1));
|
||||
CHECK_EQ(records[1].name_hash, lns::name_to_base64_hash(session_name2));
|
||||
CHECK_EQ(records[0].register_height, session_height);
|
||||
CHECK_EQ(records[1].register_height, session_height);
|
||||
CHECK_EQ(records[0].encrypted_value, helper_encrypt_lns_value(session_name1, bob_key.session_value));
|
||||
|
|
@ -1207,8 +1207,8 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
|
|||
|
||||
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::lokinet_1year))
|
||||
{
|
||||
CHECK_EQ(records[2].name_hash, lns::name_to_hash(lokinet_name1));
|
||||
CHECK_EQ(records[3].name_hash, lns::name_to_hash(lokinet_name2));
|
||||
CHECK_EQ(records[2].name_hash, lns::name_to_base64_hash(lokinet_name1));
|
||||
CHECK_EQ(records[3].name_hash, lns::name_to_base64_hash(lokinet_name2));
|
||||
CHECK_EQ(records[2].register_height, lokinet_height);
|
||||
CHECK_EQ(records[3].register_height, lokinet_height);
|
||||
CHECK_EQ(records[2].encrypted_value, helper_encrypt_lns_value(lokinet_name1, bob_key.lokinet_value));
|
||||
|
|
@ -1219,8 +1219,8 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
|
|||
|
||||
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::wallet))
|
||||
{
|
||||
CHECK_EQ(records[4].name_hash, lns::name_to_hash(wallet_name1));
|
||||
CHECK_EQ(records[5].name_hash, lns::name_to_hash(wallet_name2));
|
||||
CHECK_EQ(records[4].name_hash, lns::name_to_base64_hash(wallet_name1));
|
||||
CHECK_EQ(records[5].name_hash, lns::name_to_base64_hash(wallet_name2));
|
||||
CHECK_EQ(records[4].register_height, wallet_height);
|
||||
CHECK_EQ(records[5].register_height, wallet_height);
|
||||
CHECK_EQ(records[4].encrypted_value, helper_encrypt_lns_value(wallet_name1, bob_key.wallet_value));
|
||||
|
|
@ -1296,7 +1296,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
|
|||
return lhs.register_height < rhs.register_height;
|
||||
});
|
||||
CHECK_EQ(records[0].type, lns::mapping_type::session);
|
||||
CHECK_EQ(records[0].name_hash, lns::name_to_hash(session_name1));
|
||||
CHECK_EQ(records[0].name_hash, lns::name_to_base64_hash(session_name1));
|
||||
CHECK_EQ(records[0].encrypted_value, helper_encrypt_lns_value(session_name1, bob_key.session_value));
|
||||
CHECK_EQ(records[0].register_height, session_height1);
|
||||
CHECK_EQ(records[0].prev_txid, crypto::null_hash);
|
||||
|
|
@ -1304,7 +1304,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
|
|||
CHECK_EQ(records[0].owner, bob_key.ed_key);
|
||||
|
||||
CHECK_EQ(records[1].type, lns::mapping_type::session);
|
||||
CHECK_EQ(records[1].name_hash, lns::name_to_hash(session_name2));
|
||||
CHECK_EQ(records[1].name_hash, lns::name_to_base64_hash(session_name2));
|
||||
CHECK_EQ(records[1].encrypted_value, helper_encrypt_lns_value(session_name2, bob_key.session_value));
|
||||
CHECK_EQ(records[1].register_height, session_height2);
|
||||
CHECK_EQ(records[1].prev_txid, crypto::null_hash);
|
||||
|
|
@ -1312,7 +1312,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
|
|||
CHECK_EQ(records[1].owner, bob_key.ed_key);
|
||||
|
||||
CHECK_EQ(records[2].type, lns::mapping_type::session);
|
||||
CHECK_EQ(records[2].name_hash, lns::name_to_hash(session_name3));
|
||||
CHECK_EQ(records[2].name_hash, lns::name_to_base64_hash(session_name3));
|
||||
CHECK_EQ(records[2].encrypted_value, helper_encrypt_lns_value(session_name3, miner_key.session_value));
|
||||
CHECK_EQ(records[2].register_height, session_height3);
|
||||
CHECK_EQ(records[2].prev_txid, crypto::null_hash);
|
||||
|
|
@ -1358,7 +1358,7 @@ bool loki_name_system_get_mappings::generate(std::vector<test_event_entry> &even
|
|||
DEFINE_TESTS_ERROR_CONTEXT("check_lns_entries");
|
||||
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
|
||||
|
||||
crypto::hash session_name_hash = lns::name_to_hash(session_name1);
|
||||
std::string session_name_hash = lns::name_to_base64_hash(session_name1);
|
||||
std::vector<lns::mapping_record> records = lns_db.get_mappings({static_cast<uint16_t>(lns::mapping_type::session)}, session_name_hash);
|
||||
CHECK_EQ(records.size(), 1);
|
||||
CHECK_EQ(records[0].type, lns::mapping_type::session);
|
||||
|
|
@ -1432,7 +1432,7 @@ bool loki_name_system_handles_duplicate_in_lns_db::generate(std::vector<test_eve
|
|||
CHECK_EQ(owner.id, 1);
|
||||
CHECK_EQ(miner_key.ed_key, owner.key);
|
||||
|
||||
crypto::hash session_name_hash = lns::name_to_hash(session_name);
|
||||
std::string session_name_hash = lns::name_to_base64_hash(session_name);
|
||||
lns::mapping_record mappings = lns_db.get_mapping(lns::mapping_type::session, session_name_hash);
|
||||
CHECK_EQ(mappings.loaded, true);
|
||||
CHECK_EQ(mappings.type, lns::mapping_type::session);
|
||||
|
|
@ -1706,19 +1706,19 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
|
|||
{
|
||||
if (record.type == lns::mapping_type::session)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_session_name1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_session_name1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_session_name1, miner_key.session_value));
|
||||
}
|
||||
else if (record.type == lns::mapping_type::lokinet_1year)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_lokinet_domain1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_lokinet_domain1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_lokinet_domain1, miner_key.lokinet_value));
|
||||
}
|
||||
else if (record.type == lns::mapping_type::wallet)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_wallet_name1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_wallet_name1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_wallet_name1, miner_key.wallet_value));
|
||||
}
|
||||
|
|
@ -1764,19 +1764,19 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
|
|||
{
|
||||
if (record.type == lns::mapping_type::session)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_session_name1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_session_name1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_session_name1, miner_key.session_value));
|
||||
}
|
||||
else if (record.type == lns::mapping_type::lokinet_1year)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_lokinet_domain1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_lokinet_domain1));
|
||||
CHECK_EQ(record.register_height, second_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_lokinet_domain1, miner_key.lokinet_value));
|
||||
}
|
||||
else if (record.type == lns::mapping_type::wallet)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_wallet_name1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_wallet_name1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_wallet_name1, miner_key.wallet_value));
|
||||
}
|
||||
|
|
@ -1791,7 +1791,7 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
|
|||
{
|
||||
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.ed_key);
|
||||
CHECK_EQ(records.size(), 1);
|
||||
CHECK_EQ(records[0].name_hash, lns::name_to_hash(bob_session_name1));
|
||||
CHECK_EQ(records[0].name_hash, lns::name_to_base64_hash(bob_session_name1));
|
||||
CHECK_EQ(records[0].register_height, second_lns_height);
|
||||
CHECK_EQ(records[0].encrypted_value, helper_encrypt_lns_value(bob_session_name1, bob_key.session_value));
|
||||
CHECK_EQ(records[0].type, lns::mapping_type::session);
|
||||
|
|
@ -1833,19 +1833,19 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
|
|||
{
|
||||
if (record.type == lns::mapping_type::session)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_session_name1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_session_name1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_session_name1, miner_key.session_value));
|
||||
}
|
||||
else if (record.type == lns::mapping_type::lokinet_1year)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_lokinet_domain1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_lokinet_domain1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_lokinet_domain1, miner_key.lokinet_value));
|
||||
}
|
||||
else if (record.type == lns::mapping_type::wallet)
|
||||
{
|
||||
CHECK_EQ(record.name_hash, lns::name_to_hash(miner_wallet_name1));
|
||||
CHECK_EQ(record.name_hash, lns::name_to_base64_hash(miner_wallet_name1));
|
||||
CHECK_EQ(record.register_height, first_lns_height);
|
||||
CHECK_EQ(record.encrypted_value, helper_encrypt_lns_value(miner_wallet_name1, miner_key.wallet_value));
|
||||
}
|
||||
|
|
@ -1920,7 +1920,7 @@ bool loki_name_system_name_renewal::generate(std::vector<test_event_entry> &even
|
|||
CHECK_EQ(owner.id, 1);
|
||||
CHECK_EQ(miner_key.ed_key, owner.key);
|
||||
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
std::string name_hash = lns::name_to_base64_hash(name);
|
||||
lns::mapping_record mappings = lns_db.get_mapping(lns::mapping_type::lokinet_1year, name_hash);
|
||||
CHECK_EQ(mappings.loaded, true);
|
||||
CHECK_EQ(mappings.type, lns::mapping_type::lokinet_1year);
|
||||
|
|
@ -1950,7 +1950,7 @@ bool loki_name_system_name_renewal::generate(std::vector<test_event_entry> &even
|
|||
CHECK_EQ(owner.id, 1);
|
||||
CHECK_EQ(miner_key.ed_key, owner.key);
|
||||
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
std::string name_hash = lns::name_to_base64_hash(name);
|
||||
lns::mapping_record mappings = lns_db.get_mapping(lns::mapping_type::lokinet_1year, name_hash);
|
||||
CHECK_EQ(mappings.loaded, true);
|
||||
CHECK_EQ(mappings.type, lns::mapping_type::lokinet_1year);
|
||||
|
|
@ -2005,7 +2005,7 @@ bool loki_name_system_name_value_max_lengths::generate(std::vector<test_event_en
|
|||
if (lns::mapping_type_allowed(gen.hardfork(), lns::mapping_type::wallet))
|
||||
{
|
||||
std::string name(lns::WALLET_NAME_MAX, 'A');
|
||||
data.type = lns::mapping_type::wallet;
|
||||
data.type = lns::mapping_type::wallet;
|
||||
data.name_hash = lns::name_to_hash(name);
|
||||
data.encrypted_value = helper_encrypt_lns_value(name, miner_key.wallet_value).to_string();
|
||||
make_lns_tx_with_custom_extra(gen, events, miner, data);
|
||||
|
|
@ -2077,7 +2077,7 @@ bool loki_name_system_update_mapping_after_expiry_fails::generate(std::vector<te
|
|||
CHECK_EQ(owner.id, 1);
|
||||
CHECK_EQ(miner_key.ed_key, owner.key);
|
||||
|
||||
crypto::hash name_hash = lns::name_to_hash(name);
|
||||
std::string name_hash = lns::name_to_base64_hash(name);
|
||||
lns::mapping_record mappings = lns_db.get_mapping(lns::mapping_type::lokinet_1year, name_hash);
|
||||
CHECK_EQ(mappings.loaded, true);
|
||||
CHECK_EQ(mappings.type, lns::mapping_type::lokinet_1year);
|
||||
|
|
@ -2132,7 +2132,7 @@ bool loki_name_system_update_mapping::generate(std::vector<test_event_entry> &ev
|
|||
DEFINE_TESTS_ERROR_CONTEXT("check_updated");
|
||||
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
|
||||
|
||||
crypto::hash name_hash = lns::name_to_hash(session_name1);
|
||||
std::string name_hash = lns::name_to_base64_hash(session_name1);
|
||||
std::vector<lns::mapping_record> records = lns_db.get_mappings({static_cast<uint16_t>(lns::mapping_type::session)}, name_hash);
|
||||
|
||||
CHECK_EQ(records.size(), 1);
|
||||
|
|
|
|||
Loading…
Reference in a new issue