oxen-io
/
oxen-core
mirror of https://github.com/oxen-io/oxen-core.git
2
1
Fork 0
Code Issues Projects Releases Wiki Activity

Make LNS take generic keys/sigs where it can for owner keys

This commit is contained in:
Doyle 2020-02-26 11:41:53 +11:00
parent e905be5ebf
commit 9071ecbc92
12 changed files with 211 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/cryptonote_basic/tx_extra.h
View File

@ -65,9 +65,10 @@
namespace lns
{
enum struct tx_command_t : uint8_t
enum struct tx_command : uint8_t
{
buy,
buy_no_backup,
update,
_count,
};
@ -396,27 +397,42 @@ namespace cryptonote
struct tx_extra_loki_name_system
{
uint8_t version = 0;
lns::tx_command_t command;
lns::mapping_type type; // alias to lns::mapping_type
crypto::ed25519_public_key owner; // only serialized if command == tx_command_t::buy
crypto::ed25519_signature signature; // only serialized if command == tx_command_t::update
lns::mapping_type type;
lns::tx_command command;
crypto::generic_public_key owner = {}; // only serialized if command == tx_command::buy
crypto::generic_public_key backup_owner = {}; // only serialized if command == tx_command::buy
crypto::generic_signature signature; // only serialized if command == tx_command::update
crypto::hash name_hash;
std::string encrypted_value; // encrypted binary format of the value in the name->value mapping
crypto::hash prev_txid = crypto::null_hash; // previous txid that purchased the mapping
crypto::hash prev_txid = crypto::null_hash; // previous txid that purchased the mapping
bool is_buying() const { return (command == lns::tx_command::buy || command == lns::tx_command::buy_no_backup); }
static tx_extra_loki_name_system make_buy(crypto::ed25519_public_key const &owner, lns::mapping_type type, crypto::hash const &name_hash, std::string const &encrypted_value, crypto::hash const &prev_txid)
static tx_extra_loki_name_system make_buy(crypto::generic_public_key const &owner, crypto::generic_public_key const *backup_owner, lns::mapping_type type, crypto::hash const &name_hash, std::string const &encrypted_value, crypto::hash const &prev_txid)
{
tx_extra_loki_name_system result = {};
result.owner = owner;
result.type = type;
result.name_hash = name_hash;
result.encrypted_value = encrypted_value;
result.prev_txid = prev_txid;
result.command = lns::tx_command_t::buy;
if (backup_owner)
{
result.backup_owner = *backup_owner;
result.command = lns::tx_command::buy;
}
else
{
result.command = lns::tx_command::buy_no_backup;
}
result.type = type;
result.name_hash = name_hash;
result.encrypted_value = encrypted_value;
result.prev_txid = prev_txid;
return result;
}
static tx_extra_loki_name_system make_update(crypto::ed25519_signature const &signature, lns::mapping_type type, crypto::hash const &name_hash, std::string const &encrypted_value, crypto::hash const &prev_txid)
static tx_extra_loki_name_system make_update(crypto::generic_signature const &signature,
lns::mapping_type type,
crypto::hash const &name_hash,
std::string const &encrypted_value,
crypto::hash const &prev_txid)
{
tx_extra_loki_name_system result = {};
result.signature = signature;
@ -424,16 +440,19 @@ namespace cryptonote
result.name_hash = name_hash;
result.encrypted_value = encrypted_value;
result.prev_txid = prev_txid;
result.command = lns::tx_command_t::update;
result.command = lns::tx_command::update;
return result;
}
BEGIN_SERIALIZE()
FIELD(version)
ENUM_FIELD(type, type < lns::mapping_type::_count)
ENUM_FIELD(command, command < lns::tx_command_t::_count)
if (command == lns::tx_command_t::buy)
ENUM_FIELD(command, command < lns::tx_command::_count)
if (command == lns::tx_command::buy || command == lns::tx_command::buy_no_backup)
{
FIELD(owner)
if (command == lns::tx_command::buy) FIELD(backup_owner);
}
else
FIELD(signature)
FIELD(name_hash)

41
src/cryptonote_core/loki_name_system.cpp
View File

@ -585,8 +585,11 @@ bool validate_encrypted_mapping_value(mapping_type type, std::string const &valu
static std::ostream &operator<<(std::ostream &stream, cryptonote::tx_extra_loki_name_system const &data)
{
stream << "LNS Extra={";
if (data.command == lns::tx_command_t::buy)
if (data.is_buying())
{
stream << "owner=" << data.owner;
if (data.backup_owner) stream << "backup_owner=" << data.backup_owner;
}
else
stream << "signature=" << epee::string_tools::pod_to_hex(data.signature);
@ -600,13 +603,25 @@ static std::string hash_to_base64(crypto::hash const &hash)
return result;
}
static bool verify_lns_signature(crypto::hash const &hash, crypto::generic_signature const &signature, crypto::generic_public_key const &key)
{
if (!key) return false;
if (crypto_sign_verify_detached(signature.data, reinterpret_cast<unsigned char const *>(hash.data), sizeof(hash.data), key.data) != 0)
{
if (!crypto::check_signature(hash, key.monero, signature.monero))
return false;
}
return true;
}
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;
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;
const bool updating = data.command == lns::tx_command::update;
if (updating && !mapping)
{
if (reason)
@ -645,7 +660,7 @@ static bool validate_against_previous_mapping(lns::name_system_db const &lns_db,
// Validate signature
{
crypto::hash hash = tx_extra_signature_hash(epee::span<const uint8_t>(reinterpret_cast<const uint8_t *>(data.encrypted_value.data()), data.encrypted_value.size()), expected_prev_txid);
if (crypto_sign_verify_detached(data.signature.data, reinterpret_cast<unsigned char *>(hash.data), sizeof(hash.data), mapping.owner.data) != 0)
if (!verify_lns_signature(hash, data.signature, mapping.owner) && !verify_lns_signature(hash, data.signature, mapping.backup_owner))
{
if (reason)
{
@ -656,7 +671,8 @@ static bool validate_against_previous_mapping(lns::name_system_db const &lns_db,
}
}
data.owner = mapping.owner;
data.owner = mapping.owner;
data.backup_owner = mapping.backup_owner;
}
else
{
@ -799,16 +815,15 @@ bool name_system_db::validate_lns_tx(uint8_t hf_version, uint64_t blockchain_hei
return false;
}
const bool updating = entry->command == lns::tx_command_t::update;
uint64_t burn = cryptonote::get_burned_amount_from_tx_extra(tx.extra);
uint64_t burn_required = updating ? 0 : burn_needed(hf_version, entry->type);
uint64_t burn = cryptonote::get_burned_amount_from_tx_extra(tx.extra);
uint64_t const burn_required = entry->is_buying() ? burn_needed(hf_version, entry->type) : 0;
if (burn != burn_required)
{
if (reason)
{
char const *over_or_under = burn > burn_required ? "too much " : "insufficient ";
err_stream << tx << ", " << *entry << ", burned " << over_or_under << "loki=" << burn << ", require=" << burn_required;
if (updating) err_stream << ", updating requires just the ordinary transaction fee";
if (!entry->is_buying()) err_stream << ", updating requires just the ordinary transaction fee";
*reason = err_stream.str();
}
return false;
@ -1074,7 +1089,7 @@ static bool add_lns_entry(lns::name_system_db &lns_db, uint64_t height, cryptono
if (owner_record owner = lns_db.get_owner_by_key(entry.owner)) owner_id = owner.id;
if (owner_id == 0)
{
if (entry.command == lns::tx_command_t::update)
if (entry.command == lns::tx_command::update)
{
MERROR("Owner does not exist but TX received is trying to update an existing mapping (i.e. owner should already exist). TX=" << tx_hash << " should have failed validation prior.");
return false;
@ -1228,7 +1243,7 @@ void name_system_db::block_detach(cryptonote::Blockchain const &blockchain, uint
}
bool name_system_db::save_owner(crypto::ed25519_public_key const &key, int64_t *row_id)
bool name_system_db::save_owner(crypto::generic_public_key const &key, int64_t *row_id)
{
sqlite3_stmt *statement = save_owner_sql;
sqlite3_clear_bindings(statement);
@ -1279,7 +1294,7 @@ bool name_system_db::prune_db(uint64_t height)
return true;
}
owner_record name_system_db::get_owner_by_key(crypto::ed25519_public_key const &key) const
owner_record name_system_db::get_owner_by_key(crypto::generic_public_key const &key) const
{
sqlite3_stmt *statement = get_owner_by_key_sql;
sqlite3_clear_bindings(statement);
@ -1356,7 +1371,7 @@ std::vector<mapping_record> name_system_db::get_mappings(std::vector<uint16_t> c
return result;
}
std::vector<mapping_record> name_system_db::get_mappings_by_owners(std::vector<crypto::ed25519_public_key> const &keys) const
std::vector<mapping_record> name_system_db::get_mappings_by_owners(std::vector<crypto::generic_public_key> const &keys) const
{
std::string sql_statement;
// Generate string statement
@ -1392,7 +1407,7 @@ std::vector<mapping_record> name_system_db::get_mappings_by_owners(std::vector<c
return result;
}
std::vector<mapping_record> name_system_db::get_mappings_by_owner(crypto::ed25519_public_key const &key) const
std::vector<mapping_record> name_system_db::get_mappings_by_owner(crypto::generic_public_key const &key) const
{
std::vector<mapping_record> result = {};
sqlite3_stmt *statement = get_mappings_by_owner_sql;

19
src/cryptonote_core/loki_name_system.h
View File

@ -95,7 +95,7 @@ struct owner_record
bool loaded;
int64_t id;
crypto::ed25519_public_key key;
crypto::generic_public_key key;
};
struct settings_record
@ -124,7 +124,9 @@ struct mapping_record
mapping_value encrypted_value;
uint64_t register_height;
int64_t owner_id;
crypto::ed25519_public_key owner;
crypto::generic_public_key owner;
crypto::generic_public_key backup_owner;
int64_t backup_owner_id;
crypto::hash txid;
crypto::hash prev_txid;
};
@ -139,20 +141,19 @@ struct name_system_db
// Signifies the blockchain has reorganized commences the rollback and pruning procedures.
void block_detach(cryptonote::Blockchain const &blockchain, uint64_t new_blockchain_height);
bool save_owner (crypto::ed25519_public_key const &key, int64_t *row_id);
bool save_mapping (crypto::hash const &tx_hash, cryptonote::tx_extra_loki_name_system const &src, uint64_t height, int64_t owner_id);
bool save_settings(uint64_t top_height, crypto::hash const &top_hash, int version);
bool save_owner (crypto::generic_public_key const &key, int64_t *row_id);
bool save_mapping (crypto::hash const &tx_hash, cryptonote::tx_extra_loki_name_system const &src, uint64_t height, int64_t owner_id);
bool save_settings (uint64_t top_height, crypto::hash const &top_hash, int version);
// Delete all mappings that are registered on height or newer followed by deleting all owners no longer referenced in the DB
bool prune_db(uint64_t height);
owner_record get_owner_by_key (crypto::ed25519_public_key const &key) const;
owner_record get_owner_by_key (crypto::generic_public_key const &key) const;
owner_record get_owner_by_id (int64_t owner_id) 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;
std::vector<mapping_record> get_mappings_by_owner (crypto::generic_public_key const &key) const;
std::vector<mapping_record> get_mappings_by_owners(std::vector<crypto::generic_public_key> const &keys) const;
settings_record get_settings () const;
// entry: (optional) if function returns true, the Loki Name System entry in the TX extra is copied into 'entry'

6
src/rpc/core_rpc_server.cpp
View File

@ -3412,14 +3412,14 @@ namespace cryptonote
if (exceeds_quantity_limit(ctx, error_resp, m_restricted, req.entries.size(), COMMAND_RPC_GET_LNS_OWNERS_TO_NAMES::MAX_REQUEST_ENTRIES))
return false;
std::map<crypto::ed25519_public_key, size_t> key_to_request_index;
std::vector<crypto::ed25519_public_key> keys;
std::map<crypto::generic_public_key, size_t> key_to_request_index;
std::vector<crypto::generic_public_key> keys;
keys.reserve(req.entries.size());
for (size_t request_index = 0; request_index < req.entries.size(); request_index++)
{
std::string const &owner = req.entries[request_index];
crypto::ed25519_public_key pkey;
crypto::generic_public_key pkey;
if (!epee::string_tools::hex_to_pod(owner, pkey))
{
error_resp.code = CORE_RPC_ERROR_CODE_WRONG_PARAM;

26
src/simplewallet/simplewallet.cpp
View File

@ -269,7 +269,7 @@ namespace
const char* USAGE_STAKE("stake [index=<N1>[,<N2>,...]] [<priority>] <service node pubkey> <amount|percent%>");
const char* USAGE_REQUEST_STAKE_UNLOCK("request_stake_unlock <service_node_pubkey>");
const char* USAGE_PRINT_LOCKED_STAKES("print_locked_stakes");
const char* USAGE_BUY_LNS_MAPPING("buy_lns_mapping [index=<N1>[,<N2>,...]] [<priority>] [owner] \"<name>\" <value>");
const char* USAGE_BUY_LNS_MAPPING("buy_lns_mapping [index=<N1>[,<N2>,...]] [<priority>] [owner=] [backup_owner=] \"<name>\" <value>");
const char* USAGE_UPDATE_LNS_MAPPING("update_lns_mapping [index=<N1>[,<N2>,...]] [<priority>] \"<name>\" <value> [<signature>]");
const char* USAGE_PRINT_LNS_OWNERS_TO_NAME_HASHES("print_lns_owners_to_name_hashes [<64 hex character ed25519 public key>]");
const char* USAGE_PRINT_LNS_NAME_TO_OWNERS("print_lns_name_to_owners [type=<N1|all>[,<N2>...]] \"name\"");
@ -6388,11 +6388,26 @@ bool simple_wallet::buy_lns_mapping(const std::vector<std::string>& args)
return true;
}
std::string owner;
if (bool has_owner = (local_args.size() == 3))
std::string owner = {};
std::string backup_owner = {};
{
owner = local_args[0];
local_args.erase(local_args.begin());
char const OWNER_PREFIX[] = "owner=";
char const BACKUP_OWNER_PREFIX[] = "backup_owner=";
size_t const OWNER_LEN = loki::char_count(OWNER_PREFIX) + (sizeof(crypto::generic_public_key) * 2);
size_t const BACKUP_OWNER_LEN = loki::char_count(BACKUP_OWNER_PREFIX) + (sizeof(crypto::generic_public_key) * 2);
for (auto it = args.begin(); it != args.end(); it++)
{
// Check prefix of argument is <owner>= and extract keys out
if (it->size() == OWNER_LEN && memcmp(it->data(), OWNER_PREFIX, loki::char_count(OWNER_PREFIX)) == 0)
{
owner = it->substr(loki::char_count(OWNER_PREFIX), it->size() - loki::char_count(OWNER_PREFIX));
}
else if (it->size() == BACKUP_OWNER_LEN && memcmp(it->data(), BACKUP_OWNER_PREFIX, loki::char_count(BACKUP_OWNER_PREFIX)) == 0)
{
backup_owner = it->substr(loki::char_count(BACKUP_OWNER_PREFIX), it->size() - loki::char_count(BACKUP_OWNER_PREFIX));
}
}
}
std::string const &value = local_args[local_args.size() - 1];
@ -6414,6 +6429,7 @@ bool simple_wallet::buy_lns_mapping(const std::vector<std::string>& args)
{
ptx_vector = m_wallet->create_buy_lns_mapping_tx(lns::mapping_type::session,
owner,
backup_owner,
name,
value,
&reason,

50
src/wallet/wallet2.cpp
View File

@ -8514,6 +8514,7 @@ static bool prepare_tx_extra_loki_name_system_values(cryptonote::network_type ne
std::vector<wallet2::pending_tx> wallet2::create_buy_lns_mapping_tx(lns::mapping_type type,
std::string const &owner,
std::string const &backup_owner,
std::string const &name,
std::string const &value,
std::string *reason,
@ -8521,19 +8522,31 @@ std::vector<wallet2::pending_tx> wallet2::create_buy_lns_mapping_tx(lns::mapping
uint32_t account_index,
std::set<uint32_t> subaddr_indices)
{
crypto::ed25519_public_key pkey;
if (owner.size())
crypto::generic_public_key owner_pkey = {};
crypto::generic_public_key backup_owner_pkey = {};
if (owner.empty() && backup_owner.empty())
{
if (!epee::string_tools::hex_to_pod(owner, pkey))
{
if (reason) *reason = "Failed to convert owner to a ed25519 key, owner = " + owner;
return {};
}
owner_pkey.monero = m_account.get_keys().m_account_address.m_spend_public_key;
}
else
{
crypto::ed25519_secret_key skey;
crypto_sign_ed25519_seed_keypair(pkey.data, skey.data, reinterpret_cast<const unsigned char *>(&m_account.get_keys().m_spend_secret_key));
if (owner.size())
{
if (!epee::string_tools::hex_to_pod(owner, owner_pkey))
{
if (reason) *reason = "Failed to convert owner to a public key, owner=" + owner_pkey;
return {};
}
}
if (backup_owner.size())
{
if (!epee::string_tools::hex_to_pod(backup_owner, backup_owner_pkey))
{
if (reason) *reason = "Failed to convert backup owner to a public key, backup_owner=" + backup_owner;
return {};
}
}
}
lns::mapping_value encrypted_value;
@ -8542,7 +8555,12 @@ std::vector<wallet2::pending_tx> wallet2::create_buy_lns_mapping_tx(lns::mapping
return {};
std::vector<uint8_t> extra;
auto entry = cryptonote::tx_extra_loki_name_system::make_buy(pkey, type, lns::name_to_hash(name), encrypted_value.to_string(), prev_txid);
auto entry = cryptonote::tx_extra_loki_name_system::make_buy(owner_pkey,
backup_owner.size() ? &backup_owner_pkey : nullptr,
type,
lns::name_to_hash(name),
encrypted_value.to_string(),
prev_txid);
add_loki_name_system_to_tx_extra(extra, entry);
boost::optional<uint8_t> hf_version = get_hard_fork_version();
@ -8566,6 +8584,7 @@ std::vector<wallet2::pending_tx> wallet2::create_buy_lns_mapping_tx(lns::mapping
std::vector<wallet2::pending_tx> wallet2::create_buy_lns_mapping_tx(std::string const &type,
std::string const &owner,
std::string const &backup_owner,
std::string const &name,
std::string const &value,
std::string *reason,
@ -8577,7 +8596,7 @@ std::vector<wallet2::pending_tx> wallet2::create_buy_lns_mapping_tx(std::string
if (!lns::validate_mapping_type(type, &mapping_type, reason))
return {};
std::vector<wallet2::pending_tx> result = create_buy_lns_mapping_tx(type, owner, name, value, reason, priority, account_index, subaddr_indices);
std::vector<wallet2::pending_tx> result = create_buy_lns_mapping_tx(mapping_type, owner, backup_owner, name, value, reason, priority, account_index, subaddr_indices);
return result;
}
@ -8595,8 +8614,8 @@ std::vector<wallet2::pending_tx> wallet2::create_update_lns_mapping_tx(lns::mapp
if (!prepare_tx_extra_loki_name_system_values(nettype(), type, priority, name, value, *this, prev_txid, value_blob, reason))
return {};
crypto::ed25519_public_key pkey;
crypto::ed25519_signature signature_binary;
crypto::generic_public_key pkey;
crypto::generic_signature signature_binary;
if (signature)
{
if (!epee::string_tools::hex_to_pod(*signature, signature_binary))
@ -8607,11 +8626,8 @@ std::vector<wallet2::pending_tx> wallet2::create_update_lns_mapping_tx(lns::mapp
}
else
{
crypto::ed25519_secret_key skey;
crypto_sign_ed25519_seed_keypair(pkey.data, skey.data, reinterpret_cast<const unsigned char *>(&m_account.get_keys().m_spend_secret_key));
crypto::hash hash = lns::tx_extra_signature_hash(epee::span<const uint8_t>(value_blob.buffer.data(), value_blob.len), prev_txid);
crypto_sign_detached(signature_binary.data, NULL, reinterpret_cast<unsigned char *>(hash.data), sizeof(hash.data), skey.data);
crypto::generate_signature(hash, m_account.get_keys().m_account_address.m_spend_public_key, m_account.get_keys().m_spend_secret_key, signature_binary.monero);
}
std::vector<uint8_t> extra;

4
src/wallet/wallet2.h
View File

@ -1538,8 +1538,8 @@ private:
pending_tx ptx;
};
request_stake_unlock_result can_request_stake_unlock(const crypto::public_key &sn_key);
std::vector<wallet2::pending_tx> create_buy_lns_mapping_tx(lns::mapping_type type, std::string const &owner, std::string const &name, std::string const &value, std::string *reason, uint32_t priority = 0, uint32_t account_index = 0, std::set<uint32_t> subaddr_indices = {});
std::vector<wallet2::pending_tx> create_buy_lns_mapping_tx(std::string const &type, std::string const &owner, std::string const &name, std::string const &value, std::string *reason, uint32_t priority = 0, uint32_t account_index = 0, std::set<uint32_t> subaddr_indices = {});
std::vector<wallet2::pending_tx> create_buy_lns_mapping_tx(lns::mapping_type type, std::string const &owner, std::string const &backup_owner, std::string const &name, std::string const &value, std::string *reason, uint32_t priority = 0, uint32_t account_index = 0, std::set<uint32_t> subaddr_indices = {});
std::vector<wallet2::pending_tx> create_buy_lns_mapping_tx(std::string const &type, std::string const &owner, std::string const &backup_owner, std::string const &name, std::string const &value, std::string *reason, uint32_t priority = 0, uint32_t account_index = 0, std::set<uint32_t> subaddr_indices = {});
// signature: (Optional) If set, use the signature given, otherwise by default derive the signature from the wallet spend key as an ed25519 key.
// The signature is derived from the hash of the previous txid blob and previous value blob of the mapping. By default this is signed using the wallet's spend key as an ed25519 keypair.

10
src/wallet/wallet_rpc_server.cpp
View File

@ -4291,7 +4291,15 @@ namespace tools
}
std::string reason;
std::vector<wallet2::pending_tx> ptx_vector = m_wallet->create_buy_lns_mapping_tx(req.type, req.owner, req.name, req.value, &reason, req.priority, req.account_index, req.subaddr_indices);
std::vector<wallet2::pending_tx> ptx_vector = m_wallet->create_buy_lns_mapping_tx(req.type,
req.owner,
req.backup_owner,
req.name,
req.value,
&reason,
req.priority,
req.account_index,
req.subaddr_indices);
if (ptx_vector.empty())
{
er.code = WALLET_RPC_ERROR_CODE_TX_NOT_POSSIBLE;

30
src/wallet/wallet_rpc_server_commands_defs.h
View File

@ -2857,35 +2857,37 @@ namespace wallet_rpc
struct COMMAND_RPC_BUY_LNS_MAPPING
{
static constexpr char const description[] =
R"(Buy a Loki Name System mapping. Loki Name System allows multiple owners that are authorised to update the underlying mapping. By default if no owner is specified, the purchasing wallet's public spend key is set as the loki_owner.
R"(Buy a Loki Name System mapping. Loki Name System allows multiple owners that are authorised to update the underlying mapping. By default if no owner is specified, the purchasing wallet's public spend key is set as the owner.
- For Session, the recommended owner is the ed25519 public key of the user's Session ID set to ed_owner
In future, support for mappings on Blockchain wallets and Lokinet addresses will be available. Tentatively,
- for Wallets, the recommended owner is the monero ed25519 public key of the user's wallet spend key set to loki_owner
- for Lokinet, the recommended default owner is the ed25519 public key of the user's Lokinet key set to ed_owner
When specifying multiple owners, 1 ed25519 public key and 1 monero public spend key is supported per mapping. Updating the value that a name maps to requires one of the owner keys to sign the update transaction.
When specifying owners, either a Monero twist or standard ed25519 public key is supported per mapping. Updating the value that a name maps to requires one of the owner keys to sign the update transaction.
For information on updating & signing, refer to COMMAND_RPC_UPDATE_LNS_MAPPING)";
struct request_t
{
std::string type; // The mapping type, either "blockchain", "lokinet", "session" or if custom, a value between [65-65536] (0-2 map to the predefined mappings listed earlier).
std::string owner; // (Optional): The owner of the mapping (wallet spend key as ed25519 public key in hex). For Lokinet, the owner has the ability to renew the Loki Name Service entry. By default/if field is empty, it is derived from the wallet purchasing the LNS mapping.
std::string name; // The name to purchase via Loki Name Service
std::string value; // The value that the name maps to via Loki Name Service, (i.e. For wallets: name -> wallet address. For session: display name -> session public key. For Lokinet: name -> domain name).
std::string type; // The mapping type, either "blockchain", "lokinet", "session" or if custom, a value between [65-65536] (0-2 map to the predefined mappings listed earlier).
std::string owner; // (Optional): The owner's public key that has authority to update the mapping. It must be a ed25519 public key and is used to verify update transaction signatures.
std::string backup_owner; // (Optional): The owner's wallet spend public key that has authority to update the mapping. It must be a monero style public key and is used to verify update transaction signatures.
std::string name; // The name to purchase via Loki Name Service
std::string value; // The value that the name maps to via Loki Name Service, (i.e. For wallets: name -> wallet address. For session: display name -> session public key. For Lokinet: name -> domain name).
uint32_t account_index; // (Optional) Transfer from this account index. (Defaults to 0)
std::set<uint32_t> subaddr_indices; // (Optional) Transfer from this set of subaddresses. (Defaults to 0)
uint32_t priority; // Set a priority for the transaction. Accepted values are: or 0-4 for: default, unimportant, normal, elevated, priority.
bool get_tx_key; // (Optional) Return the transaction key after sending.
bool do_not_relay; // (Optional) If true, the newly created transaction will not be relayed to the loki network. (Defaults to false)
bool get_tx_hex; // Return the transaction as hex string after sending (Defaults to false)
bool get_tx_metadata; // Return the metadata needed to relay the transaction. (Defaults to false)
uint32_t account_index; // (Optional) Transfer from this account index. (Defaults to 0)
std::set<uint32_t> subaddr_indices; // (Optional) Transfer from this set of subaddresses. (Defaults to 0)
uint32_t priority; // Set a priority for the transaction. Accepted values are: or 0-4 for: default, unimportant, normal, elevated, priority.
bool get_tx_key; // (Optional) Return the transaction key after sending.
bool do_not_relay; // (Optional) If true, the newly created transaction will not be relayed to the loki network. (Defaults to false)
bool get_tx_hex; // Return the transaction as hex string after sending (Defaults to false)
bool get_tx_metadata; // Return the metadata needed to relay the transaction. (Defaults to false)
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE (type);
KV_SERIALIZE_OPT(owner, std::string(""));
KV_SERIALIZE_OPT(backup_owner, std::string(""));
KV_SERIALIZE (name);
KV_SERIALIZE (value);
KV_SERIALIZE_OPT(account_index, (uint32_t)0);
@ -2936,7 +2938,7 @@ Depending on the owner's public key(s) associated with the mapping the signature
- a monero public key, the signature is generated by using Monero's crypto::generate_signature on the hash
- a ed25519 public key, the signature is generated by using Libsodium's crypto_sign_detached on the hash
Providing the signature is an optional field and if not provided, will default to attempting to sign using the wallet's Monero-style public spend keys.)";
Providing the signature is an optional field and if not provided, will default to attempting to sign using the wallet's Monero-style spend keys.)";
struct request_t
{

21
tests/core_tests/chaingen.cpp
View File

@ -287,7 +287,7 @@ loki_chain_generator::create_and_add_loki_name_system_tx(cryptonote::account_bas
lns::mapping_type type,
lns::mapping_value const &value,
std::string const &name,
crypto::ed25519_public_key const *owner,
crypto::generic_public_key const *owner,
bool kept_by_block)
{
cryptonote::transaction t = create_loki_name_system_tx(src, type, value, name, owner);
@ -517,18 +517,17 @@ cryptonote::transaction loki_chain_generator::create_loki_name_system_tx(crypton
lns::mapping_type type,
lns::mapping_value const &value,
std::string const &name,
crypto::ed25519_public_key const *owner,
crypto::generic_public_key const *owner,
uint64_t burn) const
{
crypto::ed25519_public_key pkey = {};
crypto::generic_public_key pkey;
if (owner)
{
pkey = *owner;
}
else
{
crypto::ed25519_secret_key skey;
crypto_sign_ed25519_seed_keypair(pkey.data, skey.data, reinterpret_cast<const unsigned char *>(&src.get_keys().m_spend_secret_key));
pkey.monero = src.get_keys().m_account_address.m_spend_public_key;
}
cryptonote::block const &head = top().block;
@ -548,7 +547,7 @@ cryptonote::transaction loki_chain_generator::create_loki_name_system_tx(crypton
assert(encrypted);
std::vector<uint8_t> extra;
cryptonote::tx_extra_loki_name_system data = cryptonote::tx_extra_loki_name_system::make_buy(pkey, type, name_hash, encrypted_value.to_string(), prev_txid);
cryptonote::tx_extra_loki_name_system data = cryptonote::tx_extra_loki_name_system::make_buy(pkey, nullptr, type, name_hash, encrypted_value.to_string(), prev_txid);
cryptonote::add_loki_name_system_to_tx_extra(extra, data);
cryptonote::add_burned_amount_to_tx_extra(extra, burn);
cryptonote::transaction result = {};
@ -565,7 +564,7 @@ cryptonote::transaction loki_chain_generator::create_loki_name_system_tx_update(
lns::mapping_type type,
lns::mapping_value const &value,
std::string const &name,
crypto::ed25519_signature *signature,
crypto::generic_signature *signature,
bool use_asserts) const
{
crypto::hash name_hash = lns::name_to_hash(name);
@ -574,20 +573,16 @@ cryptonote::transaction loki_chain_generator::create_loki_name_system_tx_update(
crypto::hash prev_txid = mapping.txid;
if (use_asserts) assert(mapping);
crypto::ed25519_public_key pkey;
crypto::ed25519_secret_key skey;
crypto_sign_ed25519_seed_keypair(pkey.data, skey.data, reinterpret_cast<const unsigned char *>(&src.get_keys().m_spend_secret_key));
lns::mapping_value encrypted_value = {};
bool encrypted = lns::encrypt_mapping_value(name, value, encrypted_value);
if (use_asserts) assert(encrypted);
crypto::ed25519_signature signature_ = {};
crypto::generic_signature signature_ = {};
if (!signature)
{
signature = &signature_;
crypto::hash hash = lns::tx_extra_signature_hash(epee::span<const uint8_t>(reinterpret_cast<const uint8_t *>(encrypted_value.buffer.data()), encrypted_value.len), prev_txid);
crypto_sign_detached(signature->data, NULL, reinterpret_cast<unsigned char *>(hash.data), sizeof(hash.data), skey.data);
crypto::generate_signature(hash, src.get_keys().m_account_address.m_spend_public_key, src.get_keys().m_spend_secret_key, signature->monero);
}
std::vector<uint8_t> extra;

6
tests/core_tests/chaingen.h
View File

@ -1422,7 +1422,7 @@ struct loki_chain_generator
// NOTE: Add constructed TX to events_ and assume that it is valid to add to the blockchain. If the TX is meant to be unaddable to the blockchain use the individual create + add functions to
// be able to mark the add TX event as something that should trigger a failure.
// value: The binary representation of the value part in the name->value mapping
cryptonote::transaction create_and_add_loki_name_system_tx(cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, crypto::ed25519_public_key const *owner = nullptr, bool kept_by_block = false);
cryptonote::transaction create_and_add_loki_name_system_tx(cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, crypto::generic_public_key const *owner = nullptr, bool kept_by_block = false);
cryptonote::transaction create_and_add_loki_name_system_tx_update(cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, bool kept_by_block = false);
cryptonote::transaction create_and_add_tx (const cryptonote::account_base& src, const cryptonote::account_public_address& dest, uint64_t amount, uint64_t fee = TESTS_DEFAULT_FEE, bool kept_by_block = false);
cryptonote::transaction create_and_add_state_change_tx(service_nodes::new_state state, const crypto::public_key& pub_key, uint64_t height = -1, const std::vector<uint64_t>& voters = {}, uint64_t fee = 0, bool kept_by_block = false);
@ -1444,8 +1444,8 @@ struct loki_chain_generator
// value: Takes the binary value NOT the human readable version, of the name->value mapping
static const uint64_t LNS_AUTO_BURN = static_cast<uint64_t>(-1);
cryptonote::transaction create_loki_name_system_tx (cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, crypto::ed25519_public_key const *owner = nullptr, uint64_t burn = LNS_AUTO_BURN) const;
cryptonote::transaction create_loki_name_system_tx_update(cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, crypto::ed25519_signature *signature = nullptr, bool use_asserts = false) const;
cryptonote::transaction create_loki_name_system_tx (cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, crypto::generic_public_key const *owner = nullptr, uint64_t burn = LNS_AUTO_BURN) const;
cryptonote::transaction create_loki_name_system_tx_update(cryptonote::account_base const &src, lns::mapping_type type, lns::mapping_value const &value, std::string const &name, crypto::generic_signature *signature = nullptr, bool use_asserts = false) const;
cryptonote::transaction create_loki_name_system_tx_update_w_extra(cryptonote::account_base const &src, cryptonote::tx_extra_loki_name_system const &lns_extra) const;
loki_blockchain_entry create_genesis_block(const cryptonote::account_base &miner, uint64_t timestamp);

88
tests/core_tests/loki_tests.cpp
View File

@ -1014,8 +1014,7 @@ bool loki_name_system_disallow_reserved_type::generate(std::vector<test_event_en
struct lns_keys_t
{
crypto::ed25519_public_key ed_key;
crypto::ed25519_secret_key ed_skey;
crypto::generic_public_key key;
lns::mapping_value wallet_value; // NOTE: this field is the binary (value) part of the name -> (value) mapping
lns::mapping_value lokinet_value;
lns::mapping_value session_value;
@ -1023,16 +1022,15 @@ struct lns_keys_t
static lns_keys_t make_lns_keys(cryptonote::account_base const &src)
{
lns_keys_t result = {};
crypto_sign_ed25519_seed_keypair(result.ed_key.data, result.ed_skey.data, reinterpret_cast<const unsigned char *>(src.get_keys().m_spend_secret_key.data));
lns_keys_t result = {};
result.key.monero = src.get_keys().m_account_address.m_spend_public_key;
result.session_value.len = lns::SESSION_PUBLIC_KEY_BINARY_LENGTH;
result.wallet_value.len = sizeof(src.get_keys().m_account_address);
result.lokinet_value.len = sizeof(result.ed_key.data);
result.lokinet_value.len = sizeof(result.key.data);
memcpy(&result.session_value.buffer[0], &result.ed_key, sizeof(result.ed_key));
memcpy(&result.session_value.buffer[0], &result.key, sizeof(result.key));
memcpy(&result.wallet_value.buffer[0], (char *)&src.get_keys().m_account_address, result.wallet_value.len);
memcpy(&result.lokinet_value.buffer[0], (char *)result.ed_key.data, result.lokinet_value.len);
memcpy(&result.lokinet_value.buffer[0], (char *)result.key.data, result.lokinet_value.len);
result.session_value.buffer[0] = 5; // prefix with 0x05
return result;
@ -1076,10 +1074,10 @@ bool loki_name_system_expiration::generate(std::vector<test_event_entry> &events
DEFINE_TESTS_ERROR_CONTEXT("check_lns_entries");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, true);
CHECK_EQ(owner.id, 1);
CHECK_EQ(miner_key.ed_key, owner.key);
CHECK_EQ(miner_key.key, owner.key);
lns::mapping_record mappings = lns_db.get_mapping(mapping_type, name_hash);
CHECK_EQ(mappings.loaded, true);
@ -1101,10 +1099,10 @@ bool loki_name_system_expiration::generate(std::vector<test_event_entry> &events
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
// TODO(loki): We should probably expire owners that no longer have any mappings remaining
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, true);
CHECK_EQ(owner.id, 1);
CHECK_EQ(miner_key.ed_key, owner.key);
CHECK_EQ(miner_key.key, owner.key);
lns::mapping_record mappings = lns_db.get_mapping(mapping_type, name_hash);
CHECK_EQ(mappings.loaded, true);
@ -1145,7 +1143,7 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
std::string session_name2 = "AnotherName";
{
cryptonote::transaction tx1 = gen.create_and_add_loki_name_system_tx(bob, lns::mapping_type::session, bob_key.session_value, session_name1);
cryptonote::transaction tx2 = gen.create_and_add_loki_name_system_tx(miner, lns::mapping_type::session, bob_key.session_value, session_name2, &bob_key.ed_key);
cryptonote::transaction tx2 = gen.create_and_add_loki_name_system_tx(miner, lns::mapping_type::session, bob_key.session_value, session_name2, &bob_key.key);
gen.create_and_add_next_block({tx1, tx2});
}
uint64_t session_height = gen.height();
@ -1157,7 +1155,7 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
{
{
cryptonote::transaction tx1 = gen.create_and_add_loki_name_system_tx(bob, lns::mapping_type::lokinet_1year, bob_key.lokinet_value, lokinet_name1);
cryptonote::transaction tx2 = gen.create_and_add_loki_name_system_tx(miner, lns::mapping_type::lokinet_1year, bob_key.lokinet_value, lokinet_name2, &bob_key.ed_key);
cryptonote::transaction tx2 = gen.create_and_add_loki_name_system_tx(miner, lns::mapping_type::lokinet_1year, bob_key.lokinet_value, lokinet_name2, &bob_key.key);
gen.create_and_add_next_block({tx1, tx2});
}
}
@ -1171,7 +1169,7 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
{
std::string bob_addr = cryptonote::get_account_address_as_str(cryptonote::FAKECHAIN, false, bob.get_keys().m_account_address);
cryptonote::transaction tx1 = gen.create_and_add_loki_name_system_tx(bob, lns::mapping_type::wallet, bob_key.wallet_value, wallet_name1);
cryptonote::transaction tx2 = gen.create_and_add_loki_name_system_tx(miner, lns::mapping_type::wallet, bob_key.wallet_value, wallet_name2, &bob_key.ed_key);
cryptonote::transaction tx2 = gen.create_and_add_loki_name_system_tx(miner, lns::mapping_type::wallet, bob_key.wallet_value, wallet_name2, &bob_key.key);
gen.create_and_add_next_block({tx1, tx2});
}
}
@ -1185,7 +1183,7 @@ bool loki_name_system_get_mappings_by_owner::generate(std::vector<test_event_ent
{
DEFINE_TESTS_ERROR_CONTEXT("check_lns_entries");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.key);
size_t expected_size = 0;
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::session)) expected_size += 2;
@ -1290,7 +1288,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
{
DEFINE_TESTS_ERROR_CONTEXT("check_lns_entries");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owners({bob_key.ed_key, miner_key.ed_key});
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owners({bob_key.key, miner_key.key});
CHECK_EQ(records.size(), 3);
std::sort(records.begin(), records.end(), [](lns::mapping_record const &lhs, lns::mapping_record const &rhs) {
return lhs.register_height < rhs.register_height;
@ -1301,7 +1299,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
CHECK_EQ(records[0].register_height, session_height1);
CHECK_EQ(records[0].prev_txid, crypto::null_hash);
CHECK_EQ(records[0].txid, session_tx_hash1);
CHECK_EQ(records[0].owner, bob_key.ed_key);
CHECK_EQ(records[0].owner, bob_key.key);
CHECK_EQ(records[1].type, lns::mapping_type::session);
CHECK_EQ(records[1].name_hash, lns::name_to_base64_hash(session_name2));
@ -1309,7 +1307,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
CHECK_EQ(records[1].register_height, session_height2);
CHECK_EQ(records[1].prev_txid, crypto::null_hash);
CHECK_EQ(records[1].txid, session_tx_hash2);
CHECK_EQ(records[1].owner, bob_key.ed_key);
CHECK_EQ(records[1].owner, bob_key.key);
CHECK_EQ(records[2].type, lns::mapping_type::session);
CHECK_EQ(records[2].name_hash, lns::name_to_base64_hash(session_name3));
@ -1317,7 +1315,7 @@ bool loki_name_system_get_mappings_by_owners::generate(std::vector<test_event_en
CHECK_EQ(records[2].register_height, session_height3);
CHECK_EQ(records[2].prev_txid, crypto::null_hash);
CHECK_EQ(records[2].txid, session_tx_hash3);
CHECK_EQ(records[2].owner, miner_key.ed_key);
CHECK_EQ(records[2].owner, miner_key.key);
return true;
});
@ -1367,7 +1365,7 @@ bool loki_name_system_get_mappings::generate(std::vector<test_event_entry> &even
CHECK_EQ(records[0].register_height, session_height);
CHECK_EQ(records[0].prev_txid, crypto::null_hash);
CHECK_EQ(records[0].txid, session_tx_hash);
CHECK_EQ(records[0].owner, bob_key.ed_key);
CHECK_EQ(records[0].owner, bob_key.key);
return true;
});
@ -1427,10 +1425,10 @@ bool loki_name_system_handles_duplicate_in_lns_db::generate(std::vector<test_eve
DEFINE_TESTS_ERROR_CONTEXT("check_lns_entries");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, true);
CHECK_EQ(owner.id, 1);
CHECK_EQ(miner_key.ed_key, owner.key);
CHECK_EQ(miner_key.key, owner.key);
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);
@ -1463,7 +1461,7 @@ bool loki_name_system_handles_duplicate_in_lns_db::generate(std::vector<test_eve
CHECK_EQ(mappings3.owner_id, owner.id);
}
lns::owner_record owner2 = lns_db.get_owner_by_key(bob_key.ed_key);
lns::owner_record owner2 = lns_db.get_owner_by_key(bob_key.key);
CHECK_EQ(owner2.loaded, false);
return true;
});
@ -1487,8 +1485,7 @@ bool loki_name_system_handles_duplicate_in_tx_pool::generate(std::vector<test_ev
gen.add_mined_money_unlock_blocks();
}
lns_keys_t miner_key = make_lns_keys(miner);
lns_keys_t bob_key = make_lns_keys(bob);
lns_keys_t bob_key = make_lns_keys(bob);
std::string session_name = "myfriendlydisplayname.loki";
auto custom_type = static_cast<lns::mapping_type>(3928);
@ -1545,7 +1542,8 @@ bool loki_name_system_invalid_tx_extra_params::generate(std::vector<test_event_e
std::string name = "my_lns_name";
cryptonote::tx_extra_loki_name_system valid_data = {};
valid_data.owner = miner_key.ed_key;
valid_data.owner = miner_key.key;
valid_data.type = lns::mapping_type::wallet;
valid_data.encrypted_value = helper_encrypt_lns_value(name, miner_key.wallet_value).to_string();
valid_data.name_hash = lns::name_to_hash("my_lns_name");
@ -1695,7 +1693,7 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
{
DEFINE_TESTS_ERROR_CONTEXT("check_first_lns_entries");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.key);
size_t expected_size = 1;
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::wallet)) expected_size += 1;
@ -1759,7 +1757,7 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
// NOTE: Check miner's record
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::lokinet_1year))
{
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.key);
for (lns::mapping_record const &record : records)
{
if (record.type == lns::mapping_type::session)
@ -1789,7 +1787,7 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
// NOTE: Check bob's records
{
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.key);
CHECK_EQ(records.size(), 1);
CHECK_EQ(records[0].name_hash, lns::name_to_base64_hash(bob_session_name1));
CHECK_EQ(records[0].register_height, second_lns_height);
@ -1814,16 +1812,16 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
// NOTE: Check bob's records got removed due to popping back to before it existed
{
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(bob_key.key);
CHECK_EQ(records.size(), 0);
lns::owner_record owner = lns_db.get_owner_by_key(bob_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(bob_key.key);
CHECK_EQ(owner.loaded, false);
}
// NOTE: Check miner's records reverted
{
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.key);
size_t expected_size = 1;
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::wallet)) expected_size += 1;
if (lns::mapping_type_allowed(c.get_blockchain_storage().get_current_hard_fork_version(), lns::mapping_type::lokinet_1year)) expected_size += 1;
@ -1872,10 +1870,10 @@ bool loki_name_system_large_reorg::generate(std::vector<test_event_entry> &event
// NOTE: Check miner's records are gone
{
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.ed_key);
std::vector<lns::mapping_record> records = lns_db.get_mappings_by_owner(miner_key.key);
CHECK_EQ(records.size(), 0);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, false);
}
return true;
@ -1915,10 +1913,10 @@ bool loki_name_system_name_renewal::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();
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, true);
CHECK_EQ(owner.id, 1);
CHECK_EQ(miner_key.ed_key, owner.key);
CHECK_EQ(miner_key.key, owner.key);
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);
@ -1945,10 +1943,10 @@ bool loki_name_system_name_renewal::generate(std::vector<test_event_entry> &even
DEFINE_TESTS_ERROR_CONTEXT("check_renewed");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, true);
CHECK_EQ(owner.id, 1);
CHECK_EQ(miner_key.ed_key, owner.key);
CHECK_EQ(miner_key.key, owner.key);
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);
@ -1999,7 +1997,7 @@ bool loki_name_system_name_value_max_lengths::generate(std::vector<test_event_en
lns_keys_t miner_key = make_lns_keys(miner);
cryptonote::tx_extra_loki_name_system data = {};
data.owner = miner_key.ed_key;
data.owner = miner_key.key;
// Wallet
if (lns::mapping_type_allowed(gen.hardfork(), lns::mapping_type::wallet))
@ -2072,10 +2070,10 @@ bool loki_name_system_update_mapping_after_expiry_fails::generate(std::vector<te
DEFINE_TESTS_ERROR_CONTEXT("check_still_expired");
lns::name_system_db const &lns_db = c.get_blockchain_storage().name_system_db();
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.ed_key);
lns::owner_record owner = lns_db.get_owner_by_key(miner_key.key);
CHECK_EQ(owner.loaded, true);
CHECK_EQ(owner.id, 1);
CHECK_EQ(miner_key.ed_key, owner.key);
CHECK_EQ(miner_key.key, owner.key);
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);
@ -2142,7 +2140,7 @@ bool loki_name_system_update_mapping::generate(std::vector<test_event_entry> &ev
CHECK_EQ(records[0].register_height, session_height2);
CHECK_EQ(records[0].prev_txid, session_tx_hash1);
CHECK_EQ(records[0].txid, session_tx_hash2);
CHECK_EQ(records[0].owner, miner_key.ed_key);
CHECK_EQ(records[0].owner, miner_key.key);
return true;
});
@ -2180,7 +2178,7 @@ bool loki_name_system_update_mapping_invalid_signature::generate(std::vector<tes
gen.create_and_add_next_block({tx1});
lns_keys_t bob_key = make_lns_keys(gen.add_account());
crypto::ed25519_signature invalid_signature = {};
crypto::generic_signature invalid_signature = {};
cryptonote::transaction tx2 = gen.create_loki_name_system_tx_update(miner, lns::mapping_type::session, bob_key.session_value, name, &invalid_signature, false /*use_asserts*/);
gen.add_tx(tx2, false /*can_be_added_to_blockchain*/, "Can not add a updating LNS TX with an invalid signature");
return true;
@ -2306,7 +2304,7 @@ bool loki_name_system_wrong_version::generate(std::vector<test_event_entry> &eve
lns_keys_t miner_key = make_lns_keys(miner);
cryptonote::tx_extra_loki_name_system data = {};
data.version = 0xFF;
data.owner = miner_key.ed_key;
data.owner = miner_key.key;
data.type = lns::mapping_type::session;
data.name_hash = lns::name_to_hash(name);
data.encrypted_value = helper_encrypt_lns_value(name, miner_key.session_value).to_string();