aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--docs/MONZERO_ASSETS_V1_SPEC.md18
-rw-r--r--src/blockchain_db/asset_db.cpp25
-rw-r--r--src/blockchain_db/asset_db.h11
-rw-r--r--src/blockchain_db/blockchain_db.cpp5
-rw-r--r--src/blockchain_db/blockchain_db.h14
-rw-r--r--src/blockchain_db/lmdb/db_lmdb.cpp156
-rw-r--r--src/blockchain_db/lmdb/db_lmdb.h11
-rw-r--r--src/blockchain_db/testdb.h6
-rw-r--r--tests/unit_tests/blockchain_db.cpp147
9 files changed, 385 insertions, 8 deletions
diff --git a/docs/MONZERO_ASSETS_V1_SPEC.md b/docs/MONZERO_ASSETS_V1_SPEC.md
index 0d1f928e9..5a5b499b6 100644
--- a/docs/MONZERO_ASSETS_V1_SPEC.md
+++ b/docs/MONZERO_ASSETS_V1_SPEC.md
@@ -276,12 +276,18 @@ members, duplicate or zero output IDs, malformed points, key-image tampering,
and any pseudo input without exactly one matching proof. Key images must also
be unique inside one transaction.
-This still does **not** provide global double-spend prevention: production
-integration must resolve every claimed ring member against the authoritative
-asset-output database and reject key images already spent by earlier blocks or
-the mempool. Canonical wire serialization and reorg-safe output/key-image
-indexes are also outstanding. Until those layers exist and are reviewed, these
-proofs cannot make an asset transaction valid on any Monzero network.
+The inactive database prototype now persists authoritative asset outputs and
+spent asset key images in separate LMDB indexes. Ring claims can be resolved
+against those records before CLSAG verification, and block detach removes
+outputs and key images at or above the detached height. Restart, transaction
+abort, duplicate-key-image, and chain-pop tests cover this storage layer.
+
+This still does **not** provide end-to-end global double-spend prevention. The
+active transaction and mempool paths do not yet call the verifier or reserve
+key images, and accepted transactions do not yet derive and write canonical
+asset output records. Canonical wire serialization is also outstanding. Until
+those layers exist and are reviewed, these proofs cannot make an asset
+transaction valid on any Monzero network.
## 7. Metadata
diff --git a/src/blockchain_db/asset_db.cpp b/src/blockchain_db/asset_db.cpp
index d80b61028..bb2389d24 100644
--- a/src/blockchain_db/asset_db.cpp
+++ b/src/blockchain_db/asset_db.cpp
@@ -3,6 +3,8 @@
#include <algorithm>
#include <cstring>
+#include "ringct/rctOps.h"
+
namespace cryptonote
{
namespace assets
@@ -92,5 +94,28 @@ bool apply_block_extensions_to_db(BlockchainDB& db,
asset_ids = std::move(candidate_ids);
return true;
}
+
+bool verify_asset_ownership_against_db(const BlockchainDB& db,
+ const asset_ownership_proof& proof, network_type expected_network,
+ const crypto::hash& carrier_prefix_hash, std::string* error)
+{
+ if (db.has_asset_key_image(proof.key_image))
+ return fail(error, "asset key image is already spent");
+
+ for (const asset_ring_member& member : proof.ring)
+ {
+ asset_output_data_t stored{};
+ if (!db.get_asset_output(member.output_id, stored))
+ return fail(error, "asset ownership ring references an unknown output");
+ if (stored.asset_id != member.asset_id || member.asset_id != proof.asset_id)
+ return fail(error, "asset ownership ring member has the wrong asset id");
+ if (!rct::equalKeys(stored.destination, member.public_output.dest))
+ return fail(error, "asset ownership ring destination does not match consensus state");
+ if (!rct::equalKeys(stored.commitment, member.public_output.mask))
+ return fail(error, "asset ownership ring commitment does not match consensus state");
+ }
+ return verify_asset_ownership_proof(
+ proof, expected_network, carrier_prefix_hash, error);
+}
}
}
diff --git a/src/blockchain_db/asset_db.h b/src/blockchain_db/asset_db.h
index 0df5721e0..b5a763b75 100644
--- a/src/blockchain_db/asset_db.h
+++ b/src/blockchain_db/asset_db.h
@@ -4,6 +4,7 @@
#include <vector>
#include "blockchain_db.h"
+#include "cryptonote_basic/asset_confidential.h"
#include "cryptonote_basic/asset_types.h"
namespace cryptonote
@@ -27,5 +28,15 @@ namespace assets
uint64_t height,
std::vector<crypto::hash>& asset_ids,
std::string* error = nullptr);
+
+ // Resolve every claimed ring member against consensus storage and reject
+ // key images already spent by an earlier accepted asset transaction before
+ // performing the cryptographic ownership check.
+ bool verify_asset_ownership_against_db(
+ const BlockchainDB& db,
+ const asset_ownership_proof& proof,
+ network_type expected_network,
+ const crypto::hash& carrier_prefix_hash,
+ std::string* error = nullptr);
}
}
diff --git a/src/blockchain_db/blockchain_db.cpp b/src/blockchain_db/blockchain_db.cpp
index b1c4a4136..38203ddb2 100644
--- a/src/blockchain_db/blockchain_db.cpp
+++ b/src/blockchain_db/blockchain_db.cpp
@@ -318,7 +318,10 @@ void BlockchainDB::pop_block(block& blk, std::vector<transaction>& txs)
// Asset records created by the detached block are consensus state and must
// disappear in the same write transaction as the native block and tx data.
- remove_asset_records_from_height(height() - 1);
+ const uint64_t detached_height = height() - 1;
+ remove_asset_records_from_height(detached_height);
+ remove_asset_outputs_from_height(detached_height);
+ remove_asset_key_images_from_height(detached_height);
remove_block();
diff --git a/src/blockchain_db/blockchain_db.h b/src/blockchain_db/blockchain_db.h
index c176a8ef5..a52f2bdad 100644
--- a/src/blockchain_db/blockchain_db.h
+++ b/src/blockchain_db/blockchain_db.h
@@ -128,6 +128,14 @@ struct output_data_t
uint64_t height; //!< the height of the block which created the output
rct::key commitment; //!< the output's amount commitment (for spend verification)
};
+
+struct asset_output_data_t
+{
+ crypto::hash asset_id;
+ rct::key destination;
+ rct::key commitment;
+ uint64_t height;
+};
#pragma pack(pop)
#pragma pack(push, 1)
@@ -1791,6 +1799,12 @@ public:
virtual bool get_asset_record(const crypto::hash &asset_id, uint64_t &height, cryptonote::blobdata &payload) const = 0;
virtual void remove_asset_records_from_height(uint64_t height) = 0;
virtual bool for_all_asset_records(std::function<bool(const crypto::hash&, uint64_t, const cryptonote::blobdata_ref&)>) const = 0;
+ virtual void add_asset_output(const crypto::hash &output_id, const asset_output_data_t &output) = 0;
+ virtual bool get_asset_output(const crypto::hash &output_id, asset_output_data_t &output) const = 0;
+ virtual void add_asset_key_image(const crypto::key_image &key_image, uint64_t height) = 0;
+ virtual bool has_asset_key_image(const crypto::key_image &key_image) const = 0;
+ virtual void remove_asset_outputs_from_height(uint64_t height) = 0;
+ virtual void remove_asset_key_images_from_height(uint64_t height) = 0;
//
diff --git a/src/blockchain_db/lmdb/db_lmdb.cpp b/src/blockchain_db/lmdb/db_lmdb.cpp
index 0c3a4f470..4ba91b72b 100644
--- a/src/blockchain_db/lmdb/db_lmdb.cpp
+++ b/src/blockchain_db/lmdb/db_lmdb.cpp
@@ -58,7 +58,7 @@ using epee::string_tools::pod_to_hex;
using namespace crypto;
// Increase when the DB structure changes
-#define VERSION 6
+#define VERSION 7
namespace
{
@@ -239,6 +239,10 @@ const char* const LMDB_ALT_BLOCKS = "alt_blocks";
const char* const LMDB_ASSET_RECORDS = "asset_records";
const char* const LMDB_ASSET_HEIGHTS = "asset_heights";
+const char* const LMDB_ASSET_OUTPUTS = "asset_outputs";
+const char* const LMDB_ASSET_OUTPUT_HEIGHTS = "asset_output_heights";
+const char* const LMDB_ASSET_KEY_IMAGES = "asset_key_images";
+const char* const LMDB_ASSET_KEY_IMAGE_HEIGHTS = "asset_key_image_heights";
const char* const LMDB_HF_STARTING_HEIGHTS = "hf_starting_heights";
const char* const LMDB_HF_VERSIONS = "hf_versions";
@@ -1511,6 +1515,10 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
lmdb_db_open(txn, LMDB_ASSET_RECORDS, MDB_CREATE, m_asset_records, "Failed to open db handle for m_asset_records");
lmdb_db_open(txn, LMDB_ASSET_HEIGHTS, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_asset_heights, "Failed to open db handle for m_asset_heights");
+ lmdb_db_open(txn, LMDB_ASSET_OUTPUTS, MDB_CREATE, m_asset_outputs, "Failed to open db handle for m_asset_outputs");
+ lmdb_db_open(txn, LMDB_ASSET_OUTPUT_HEIGHTS, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_asset_output_heights, "Failed to open db handle for m_asset_output_heights");
+ lmdb_db_open(txn, LMDB_ASSET_KEY_IMAGES, MDB_CREATE, m_asset_key_images, "Failed to open db handle for m_asset_key_images");
+ lmdb_db_open(txn, LMDB_ASSET_KEY_IMAGE_HEIGHTS, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_asset_key_image_heights, "Failed to open db handle for m_asset_key_image_heights");
// this subdb is dropped on sight, so it may not be present when we open the DB.
// Since we use MDB_CREATE, we'll get an exception if we open read-only and it does not exist.
@@ -1538,6 +1546,10 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
mdb_set_compare(txn, m_alt_blocks, compare_hash32);
mdb_set_compare(txn, m_asset_records, compare_hash32);
mdb_set_dupsort(txn, m_asset_heights, compare_hash32);
+ mdb_set_compare(txn, m_asset_outputs, compare_hash32);
+ mdb_set_dupsort(txn, m_asset_output_heights, compare_hash32);
+ mdb_set_compare(txn, m_asset_key_images, compare_hash32);
+ mdb_set_dupsort(txn, m_asset_key_image_heights, compare_hash32);
mdb_set_compare(txn, m_properties, compare_string);
if (!(mdb_flags & MDB_RDONLY))
@@ -1714,6 +1726,14 @@ void BlockchainLMDB::reset()
throw0(DB_ERROR(lmdb_error("Failed to drop m_asset_records: ", result).c_str()));
if (auto result = mdb_drop(txn, m_asset_heights, 0))
throw0(DB_ERROR(lmdb_error("Failed to drop m_asset_heights: ", result).c_str()));
+ if (auto result = mdb_drop(txn, m_asset_outputs, 0))
+ throw0(DB_ERROR(lmdb_error("Failed to drop m_asset_outputs: ", result).c_str()));
+ if (auto result = mdb_drop(txn, m_asset_output_heights, 0))
+ throw0(DB_ERROR(lmdb_error("Failed to drop m_asset_output_heights: ", result).c_str()));
+ if (auto result = mdb_drop(txn, m_asset_key_images, 0))
+ throw0(DB_ERROR(lmdb_error("Failed to drop m_asset_key_images: ", result).c_str()));
+ if (auto result = mdb_drop(txn, m_asset_key_image_heights, 0))
+ throw0(DB_ERROR(lmdb_error("Failed to drop m_asset_key_image_heights: ", result).c_str()));
// init with current version
MDB_val_str(k, "version");
@@ -2550,6 +2570,125 @@ bool BlockchainLMDB::for_all_asset_records(std::function<bool(const crypto::hash
return ret;
}
+void BlockchainLMDB::add_asset_output(const crypto::hash &output_id, const asset_output_data_t &output)
+{
+ check_open();
+ TXN_BLOCK_PREFIX(0);
+ MDB_val key = {sizeof(output_id), const_cast<crypto::hash*>(&output_id)};
+ MDB_val value = {sizeof(output), const_cast<asset_output_data_t*>(&output)};
+ int result = mdb_put(*txn_ptr, m_asset_outputs, &key, &value, MDB_NOOVERWRITE);
+ if (result == MDB_KEYEXIST)
+ throw1(DB_ERROR("Attempting to add an asset output that already exists"));
+ if (result)
+ throw1(DB_ERROR(lmdb_error("Error adding asset output: ", result).c_str()));
+ MDB_val_copy<uint64_t> height_key(output.height);
+ MDB_val id_value = {sizeof(output_id), const_cast<crypto::hash*>(&output_id)};
+ if ((result = mdb_put(*txn_ptr, m_asset_output_heights, &height_key, &id_value, MDB_NODUPDATA)))
+ throw1(DB_ERROR(lmdb_error("Error indexing asset output height: ", result).c_str()));
+ TXN_BLOCK_POSTFIX_SUCCESS();
+}
+
+bool BlockchainLMDB::get_asset_output(const crypto::hash &output_id, asset_output_data_t &output) const
+{
+ check_open();
+ TXN_PREFIX_RDONLY();
+ MDB_val key = {sizeof(output_id), const_cast<crypto::hash*>(&output_id)}, value;
+ const int result = mdb_get(m_txn, m_asset_outputs, &key, &value);
+ if (result == MDB_NOTFOUND)
+ return false;
+ if (result)
+ throw0(DB_ERROR(lmdb_error("Error retrieving asset output: ", result).c_str()));
+ if (value.mv_size != sizeof(output))
+ throw0(DB_ERROR("Asset output record has an invalid size"));
+ std::memcpy(&output, value.mv_data, sizeof(output));
+ return true;
+}
+
+void BlockchainLMDB::add_asset_key_image(const crypto::key_image &key_image, uint64_t height)
+{
+ check_open();
+ TXN_BLOCK_PREFIX(0);
+ MDB_val key = {sizeof(key_image), const_cast<crypto::key_image*>(&key_image)};
+ MDB_val_copy<uint64_t> value(height);
+ int result = mdb_put(*txn_ptr, m_asset_key_images, &key, &value, MDB_NOOVERWRITE);
+ if (result == MDB_KEYEXIST)
+ throw1(KEY_IMAGE_EXISTS("Attempting to spend an asset key image that already exists"));
+ if (result)
+ throw1(DB_ERROR(lmdb_error("Error adding asset key image: ", result).c_str()));
+ MDB_val_copy<uint64_t> height_key(height);
+ MDB_val image_value = {sizeof(key_image), const_cast<crypto::key_image*>(&key_image)};
+ if ((result = mdb_put(*txn_ptr, m_asset_key_image_heights, &height_key, &image_value, MDB_NODUPDATA)))
+ throw1(DB_ERROR(lmdb_error("Error indexing asset key image height: ", result).c_str()));
+ TXN_BLOCK_POSTFIX_SUCCESS();
+}
+
+bool BlockchainLMDB::has_asset_key_image(const crypto::key_image &key_image) const
+{
+ check_open();
+ TXN_PREFIX_RDONLY();
+ MDB_val key = {sizeof(key_image), const_cast<crypto::key_image*>(&key_image)}, value;
+ const int result = mdb_get(m_txn, m_asset_key_images, &key, &value);
+ if (result == MDB_NOTFOUND)
+ return false;
+ if (result)
+ throw0(DB_ERROR(lmdb_error("Error retrieving asset key image: ", result).c_str()));
+ return true;
+}
+
+void BlockchainLMDB::remove_asset_outputs_from_height(uint64_t height)
+{
+ check_open();
+ TXN_BLOCK_PREFIX(0);
+ MDB_cursor *cursor = nullptr;
+ int result = mdb_cursor_open(*txn_ptr, m_asset_output_heights, &cursor);
+ if (result)
+ throw1(DB_ERROR(lmdb_error("Error opening asset output height cursor: ", result).c_str()));
+ MDB_val_copy<uint64_t> key(height);
+ MDB_val value;
+ result = mdb_cursor_get(cursor, &key, &value, MDB_SET_RANGE);
+ while (result == MDB_SUCCESS)
+ {
+ MDB_val output_key = {value.mv_size, value.mv_data};
+ const int deleted = mdb_del(*txn_ptr, m_asset_outputs, &output_key, nullptr);
+ if (deleted != MDB_SUCCESS && deleted != MDB_NOTFOUND)
+ throw1(DB_ERROR(lmdb_error("Error removing asset output: ", deleted).c_str()));
+ if ((result = mdb_cursor_del(cursor, 0)) != MDB_SUCCESS)
+ throw1(DB_ERROR(lmdb_error("Error removing asset output height: ", result).c_str()));
+ result = mdb_cursor_get(cursor, &key, &value, MDB_NEXT);
+ }
+ mdb_cursor_close(cursor);
+ if (result != MDB_NOTFOUND)
+ throw1(DB_ERROR(lmdb_error("Error iterating asset output heights: ", result).c_str()));
+ TXN_BLOCK_POSTFIX_SUCCESS();
+}
+
+void BlockchainLMDB::remove_asset_key_images_from_height(uint64_t height)
+{
+ check_open();
+ TXN_BLOCK_PREFIX(0);
+ MDB_cursor *cursor = nullptr;
+ int result = mdb_cursor_open(*txn_ptr, m_asset_key_image_heights, &cursor);
+ if (result)
+ throw1(DB_ERROR(lmdb_error("Error opening asset key-image height cursor: ", result).c_str()));
+ MDB_val_copy<uint64_t> key(height);
+ MDB_val value;
+ result = mdb_cursor_get(cursor, &key, &value, MDB_SET_RANGE);
+ while (result == MDB_SUCCESS)
+ {
+ MDB_val image_key = {value.mv_size, value.mv_data};
+ const int deleted = mdb_del(*txn_ptr, m_asset_key_images, &image_key, nullptr);
+ if (deleted != MDB_SUCCESS && deleted != MDB_NOTFOUND)
+ throw1(DB_ERROR(lmdb_error("Error removing asset key image: ", deleted).c_str()));
+ if ((result = mdb_cursor_del(cursor, 0)) != MDB_SUCCESS)
+ throw1(DB_ERROR(lmdb_error("Error removing asset key-image height: ", result).c_str()));
+ result = mdb_cursor_get(cursor, &key, &value, MDB_NEXT);
+ }
+ mdb_cursor_close(cursor);
+ if (result != MDB_NOTFOUND)
+ throw1(DB_ERROR(lmdb_error("Error iterating asset key-image heights: ", result).c_str()));
+ TXN_BLOCK_POSTFIX_SUCCESS();
+}
+
bool BlockchainLMDB::block_exists(const crypto::hash& h, uint64_t *height) const
{
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@@ -5831,6 +5970,19 @@ void BlockchainLMDB::migrate_5_6()
txn.commit();
}
+void BlockchainLMDB::migrate_6_7()
+{
+ LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+ mdb_txn_safe txn(false);
+ if (const int result = mdb_txn_begin(m_env, nullptr, 0, txn))
+ throw0(DB_ERROR(lmdb_error("Failed to create transaction for DB v7 migration: ", result).c_str()));
+ MDB_val_str(key, "version");
+ MDB_val_copy<uint32_t> value(7);
+ if (const int result = mdb_put(txn, m_properties, &key, &value, 0))
+ throw0(DB_ERROR(lmdb_error("Failed to update DB version to 7: ", result).c_str()));
+ txn.commit();
+}
+
void BlockchainLMDB::migrate(const uint32_t oldversion)
{
if (oldversion < 1)
@@ -5845,6 +5997,8 @@ void BlockchainLMDB::migrate(const uint32_t oldversion)
migrate_4_5();
if (oldversion < 6)
migrate_5_6();
+ if (oldversion < 7)
+ migrate_6_7();
}
} // namespace cryptonote
diff --git a/src/blockchain_db/lmdb/db_lmdb.h b/src/blockchain_db/lmdb/db_lmdb.h
index d116bcec5..c7851c117 100644
--- a/src/blockchain_db/lmdb/db_lmdb.h
+++ b/src/blockchain_db/lmdb/db_lmdb.h
@@ -315,6 +315,12 @@ public:
virtual bool get_asset_record(const crypto::hash &asset_id, uint64_t &height, cryptonote::blobdata &payload) const;
virtual void remove_asset_records_from_height(uint64_t height);
virtual bool for_all_asset_records(std::function<bool(const crypto::hash&, uint64_t, const cryptonote::blobdata_ref&)>) const;
+ virtual void add_asset_output(const crypto::hash &output_id, const asset_output_data_t &output);
+ virtual bool get_asset_output(const crypto::hash &output_id, asset_output_data_t &output) const;
+ virtual void add_asset_key_image(const crypto::key_image &key_image, uint64_t height);
+ virtual bool has_asset_key_image(const crypto::key_image &key_image) const;
+ virtual void remove_asset_outputs_from_height(uint64_t height);
+ virtual void remove_asset_key_images_from_height(uint64_t height);
virtual uint64_t add_block( const std::pair<block, blobdata>& blk
, size_t block_weight
@@ -449,6 +455,7 @@ private:
// migrate from DB version 5 to 6
void migrate_5_6();
+ void migrate_6_7();
void cleanup_batch();
@@ -479,6 +486,10 @@ private:
MDB_dbi m_asset_records;
MDB_dbi m_asset_heights;
+ MDB_dbi m_asset_outputs;
+ MDB_dbi m_asset_output_heights;
+ MDB_dbi m_asset_key_images;
+ MDB_dbi m_asset_key_image_heights;
MDB_dbi m_hf_starting_heights;
MDB_dbi m_hf_versions;
diff --git a/src/blockchain_db/testdb.h b/src/blockchain_db/testdb.h
index fb97ccee4..c14348245 100644
--- a/src/blockchain_db/testdb.h
+++ b/src/blockchain_db/testdb.h
@@ -170,6 +170,12 @@ public:
virtual bool get_asset_record(const crypto::hash&, uint64_t&, cryptonote::blobdata&) const override { return false; }
virtual void remove_asset_records_from_height(uint64_t) override {}
virtual bool for_all_asset_records(std::function<bool(const crypto::hash&, uint64_t, const cryptonote::blobdata_ref&)>) const override { return true; }
+ virtual void add_asset_output(const crypto::hash&, const asset_output_data_t&) override {}
+ virtual bool get_asset_output(const crypto::hash&, asset_output_data_t&) const override { return false; }
+ virtual void add_asset_key_image(const crypto::key_image&, uint64_t) override {}
+ virtual bool has_asset_key_image(const crypto::key_image&) const override { return false; }
+ virtual void remove_asset_outputs_from_height(uint64_t) override {}
+ virtual void remove_asset_key_images_from_height(uint64_t) override {}
};
}
diff --git a/tests/unit_tests/blockchain_db.cpp b/tests/unit_tests/blockchain_db.cpp
index f5149a41e..124a88724 100644
--- a/tests/unit_tests/blockchain_db.cpp
+++ b/tests/unit_tests/blockchain_db.cpp
@@ -39,7 +39,10 @@
#include "blockchain_db/blockchain_db.h"
#include "blockchain_db/asset_db.h"
#include "blockchain_db/lmdb/db_lmdb.h"
+#include "cryptonote_basic/asset_confidential.h"
#include "cryptonote_basic/cryptonote_format_utils.h"
+#include "device/device.hpp"
+#include "ringct/rctSigs.h"
using namespace cryptonote;
using epee::string_tools::pod_to_hex;
@@ -69,6 +72,45 @@ assets::transaction_extension make_asset_extension(const crypto::hash& carrier)
return extension;
}
+assets::asset_ownership_proof make_db_ownership_proof(
+ const crypto::hash& id, const crypto::hash& carrier)
+{
+ constexpr size_t real = 5;
+ assets::asset_ownership_proof proof;
+ proof.asset_id = id;
+ rct::ctkeyV public_ring;
+ rct::key spend_secret{}, input_mask{};
+ const rct::key amount = rct::d2h(10);
+ for (size_t index = 0; index < assets::CONFIDENTIAL_ASSET_RING_SIZE; ++index)
+ {
+ assets::asset_ring_member member;
+ member.asset_id = id;
+ member.output_id.data[0] = static_cast<unsigned char>(index + 1);
+ rct::key ignored;
+ rct::skpkGen(ignored, member.public_output.dest);
+ rct::skpkGen(ignored, member.public_output.mask);
+ proof.ring.push_back(member);
+ }
+ rct::skpkGen(spend_secret, proof.ring[real].public_output.dest);
+ input_mask = rct::skGen();
+ rct::addKeys2(proof.ring[real].public_output.mask, input_mask, amount, rct::H);
+ for (const auto& member : proof.ring)
+ public_ring.push_back(member.public_output);
+ const rct::key pseudo_mask = rct::skGen();
+ rct::addKeys2(proof.pseudo_input, pseudo_mask, amount, rct::H);
+ rct::key message;
+ std::string error;
+ if (!assets::derive_asset_ownership_message(proof, TESTNET, carrier, message, &error))
+ throw std::runtime_error(error);
+ rct::ctkey input_secret;
+ input_secret.dest = spend_secret;
+ input_secret.mask = input_mask;
+ proof.signature = rct::proveRctCLSAGSimple(message, public_ring, input_secret,
+ pseudo_mask, proof.pseudo_input, real, hw::get_device("default"));
+ std::memcpy(&proof.key_image, &proof.signature.I, sizeof(proof.key_image));
+ return proof;
+}
+
const std::vector<std::string> t_blocks =
{
"0100d5adc49a053b8818b2b6023cd2d532c6774e164a8fcacd603651cb3ea0cb7f9340b28ec016b4bc4ca301aa0101ff6e08acbb2702eab03067870349139bee7eab2ca2e030a6bb73d4f68ab6a3b6ca937214054cdac0843d028bbe23b57ea9bae53f12da93bb57bf8a2e40598d9fccd10c2921576e987d93cd80b4891302468738e391f07c4f2b356f7957160968e0bfef6e907c3cee2d8c23cbf04b089680c6868f01025a0f41f063e195a966051e3a29e17130a9ce97d48f55285b9bb04bdd55a09ae78088aca3cf0202d0f26169290450fe17e08974789c3458910b4db18361cdc564f8f2d0bdd2cf568090cad2c60e02d6f3483ec45505cc3be841046c7a12bf953ac973939bc7b727e54258e1881d4d80e08d84ddcb0102dae6dfb16d3e28aaaf43e00170b90606b36f35f38f8a3dceb5ee18199dd8f17c80c0caf384a30202385d7e57a4daba4cdd9e550a92dcc188838386e7581f13f09de796cbed4716a42101c052492a077abf41996b50c1b2e67fd7288bcd8c55cdc657b4e22d0804371f6901beb76a82ea17400cd6d7f595f70e1667d2018ed8f5a78d1ce07484222618c3cd"
@@ -317,6 +359,99 @@ TYPED_TEST(BlockchainDBTest, AssetRecordsPersistAndRollbackAtomically)
ASSERT_FALSE(this->m_db->get_asset_record(later, height, payload));
}
+TYPED_TEST(BlockchainDBTest, AssetOutputsAndKeyImagesPersistAndRollbackAtomically)
+{
+ const boost::filesystem::path temp_path = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
+ const std::string dir_path = temp_path.string();
+ this->set_prefix(dir_path);
+ ASSERT_NO_THROW(this->m_db->open(dir_path));
+ this->get_filenames();
+
+ crypto::hash first_id{}, later_id{}, aborted_id{}, asset_id{};
+ first_id.data[0] = 1;
+ later_id.data[0] = 2;
+ aborted_id.data[0] = 3;
+ asset_id.data[0] = 0xa7;
+ rct::key first_secret{}, first_key{}, later_key{}, aborted_key{};
+ rct::skpkGen(first_secret, first_key);
+ rct::skpkGen(first_secret, later_key);
+ rct::skpkGen(first_secret, aborted_key);
+
+ asset_output_data_t first{asset_id, first_key, rct::commit(11, rct::zero()), 30};
+ asset_output_data_t later{asset_id, later_key, rct::commit(12, rct::zero()), 31};
+ asset_output_data_t aborted{asset_id, aborted_key, rct::commit(13, rct::zero()), 32};
+ crypto::key_image spent{}, aborted_spent{};
+ reinterpret_cast<unsigned char*>(&spent)[0] = 0x41;
+ reinterpret_cast<unsigned char*>(&aborted_spent)[0] = 0x42;
+
+ ASSERT_NO_THROW(this->m_db->add_asset_output(first_id, first));
+ ASSERT_THROW(this->m_db->add_asset_output(first_id, first), DB_ERROR);
+ ASSERT_NO_THROW(this->m_db->add_asset_output(later_id, later));
+ ASSERT_NO_THROW(this->m_db->add_asset_key_image(spent, 31));
+ ASSERT_THROW(this->m_db->add_asset_key_image(spent, 31), KEY_IMAGE_EXISTS);
+
+ this->m_db->block_wtxn_start();
+ ASSERT_NO_THROW(this->m_db->add_asset_output(aborted_id, aborted));
+ ASSERT_NO_THROW(this->m_db->add_asset_key_image(aborted_spent, 32));
+ this->m_db->block_wtxn_abort();
+
+ asset_output_data_t restored{};
+ ASSERT_FALSE(this->m_db->get_asset_output(aborted_id, restored));
+ ASSERT_FALSE(this->m_db->has_asset_key_image(aborted_spent));
+ ASSERT_NO_THROW(this->m_db->close());
+ ASSERT_NO_THROW(this->m_db->open(dir_path));
+
+ ASSERT_TRUE(this->m_db->get_asset_output(first_id, restored));
+ ASSERT_EQ(first.asset_id, restored.asset_id);
+ ASSERT_EQ(first.destination, restored.destination);
+ ASSERT_EQ(first.commitment, restored.commitment);
+ ASSERT_EQ(first.height, restored.height);
+ ASSERT_TRUE(this->m_db->has_asset_key_image(spent));
+
+ ASSERT_NO_THROW(this->m_db->remove_asset_outputs_from_height(31));
+ ASSERT_NO_THROW(this->m_db->remove_asset_key_images_from_height(31));
+ ASSERT_TRUE(this->m_db->get_asset_output(first_id, restored));
+ ASSERT_FALSE(this->m_db->get_asset_output(later_id, restored));
+ ASSERT_FALSE(this->m_db->has_asset_key_image(spent));
+}
+
+TYPED_TEST(BlockchainDBTest, AssetOwnershipResolvesAuthoritativeRingAndSpentState)
+{
+ const boost::filesystem::path temp_path = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
+ const std::string dir_path = temp_path.string();
+ this->set_prefix(dir_path);
+ ASSERT_NO_THROW(this->m_db->open(dir_path));
+ this->get_filenames();
+
+ crypto::hash id{}, carrier{};
+ id.data[0] = 0x91;
+ carrier.data[0] = 0x92;
+ const auto proof = make_db_ownership_proof(id, carrier);
+ std::string error;
+ EXPECT_FALSE(assets::verify_asset_ownership_against_db(
+ *this->m_db, proof, TESTNET, carrier, &error));
+
+ for (const auto& member : proof.ring)
+ {
+ asset_output_data_t output{member.asset_id, member.public_output.dest,
+ member.public_output.mask, 40};
+ ASSERT_NO_THROW(this->m_db->add_asset_output(member.output_id, output));
+ }
+ ASSERT_TRUE(assets::verify_asset_ownership_against_db(
+ *this->m_db, proof, TESTNET, carrier, &error)) << error;
+
+ ASSERT_NO_THROW(this->m_db->add_asset_key_image(proof.key_image, 41));
+ EXPECT_FALSE(assets::verify_asset_ownership_against_db(
+ *this->m_db, proof, TESTNET, carrier, &error));
+ ASSERT_NO_THROW(this->m_db->remove_asset_key_images_from_height(41));
+ ASSERT_TRUE(assets::verify_asset_ownership_against_db(
+ *this->m_db, proof, TESTNET, carrier, &error)) << error;
+
+ ASSERT_NO_THROW(this->m_db->remove_asset_outputs_from_height(40));
+ EXPECT_FALSE(assets::verify_asset_ownership_against_db(
+ *this->m_db, proof, TESTNET, carrier, &error));
+}
+
TYPED_TEST(BlockchainDBTest, AssetBlockExtensionsRebuildFromPersistentState)
{
const boost::filesystem::path temp_path = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
@@ -370,8 +505,15 @@ TYPED_TEST(BlockchainDBTest, PopBlockRemovesAssetStateAtDetachedHeight)
this->init_hard_fork();
crypto::hash id{};
+ crypto::hash output_id{};
+ crypto::key_image spent{};
id.data[0] = 0xa5;
+ output_id.data[0] = 0xa6;
+ reinterpret_cast<unsigned char*>(&spent)[0] = 0xa7;
const blobdata payload("detached asset");
+ rct::key output_key{}, output_secret{};
+ rct::skpkGen(output_secret, output_key);
+ const asset_output_data_t asset_output{id, output_key, rct::commit(50, rct::zero()), 1};
block popped;
std::vector<transaction> transactions;
{
@@ -379,11 +521,16 @@ TYPED_TEST(BlockchainDBTest, PopBlockRemovesAssetStateAtDetachedHeight)
ASSERT_NO_THROW(this->m_db->add_block(this->m_blocks[0], t_sizes[0], t_sizes[0], t_diffs[0], t_coins[0], this->m_txs[0]));
ASSERT_NO_THROW(this->m_db->add_block(this->m_blocks[1], t_sizes[1], t_sizes[1], t_diffs[1], t_coins[1], this->m_txs[1]));
ASSERT_NO_THROW(this->m_db->add_asset_record(id, 1, blobdata_ref(payload)));
+ ASSERT_NO_THROW(this->m_db->add_asset_output(output_id, asset_output));
+ ASSERT_NO_THROW(this->m_db->add_asset_key_image(spent, 1));
}
ASSERT_NO_THROW(this->m_db->pop_block(popped, transactions));
uint64_t height = 0;
blobdata restored;
+ asset_output_data_t restored_output{};
ASSERT_FALSE(this->m_db->get_asset_record(id, height, restored));
+ ASSERT_FALSE(this->m_db->get_asset_output(output_id, restored_output));
+ ASSERT_FALSE(this->m_db->has_asset_key_image(spent));
ASSERT_EQ(1u, this->m_db->height());
}
generated by cgit v1.2.3 (git 2.51.0) at 2026-08-15 22:31:52 +0000