feat: refactor domain objects deserialization

Author: fpelliccioni

conanfile.py

@@ -84,7 +84,7 @@ def requirements(self):
 
     def build_requirements(self):
         if self.options.tests:
-            self.test_requires("catch2/3.6.0")
+            self.test_requires("catch2/3.7.1")
 
     def config_options(self):
         KnuthConanFileV2.config_options(self)

include/kth/capi/chain/transaction.h

@@ -42,11 +42,11 @@ kth_hash_t kth_chain_transaction_hash(kth_transaction_t transaction);
 KTH_EXPORT
 void kth_chain_transaction_hash_out(kth_transaction_t transaction, kth_hash_t* out_hash);
 
-KTH_EXPORT
-kth_hash_t kth_chain_transaction_hash_sighash_type(kth_transaction_t transaction, uint32_t sighash_type);
+// KTH_EXPORT
+// kth_hash_t kth_chain_transaction_hash_sighash_type(kth_transaction_t transaction, uint32_t sighash_type);
 
-KTH_EXPORT
-void kth_chain_transaction_hash_sighash_type_out(kth_transaction_t transaction, uint32_t sighash_type, kth_hash_t* out_hash);
+// KTH_EXPORT
+// void kth_chain_transaction_hash_sighash_type_out(kth_transaction_t transaction, uint32_t sighash_type, kth_hash_t* out_hash);
 
 KTH_EXPORT
 uint32_t kth_chain_transaction_locktime(kth_transaction_t transaction);

src/chain/block.cpp

@@ -27,7 +27,7 @@ kth_block_t kth_chain_block_construct(kth_header_t header, kth_transaction_list_
 
 kth_block_t kth_chain_block_factory_from_data(uint8_t* data, kth_size_t n) {
     kth::data_chunk data_cpp(data, std::next(data, n));
-    auto block = kth::domain::create<kth::domain::chain::block>(data_cpp);
+    auto block = kth::domain::create_old<kth::domain::chain::block>(data_cpp);
     return kth::move_or_copy_and_leak(std::move(block));
 }
 

src/chain/chain_async.cpp

@@ -80,14 +80,14 @@ void kth_chain_async_block_header_by_hash(kth_chain_t chain, void* ctx, kth_hash
 }
 
 void kth_chain_async_block_by_height(kth_chain_t chain, void* ctx, kth_size_t height, kth_block_fetch_handler_t handler) {
-    safe_chain(chain).fetch_block(height, kth::witness(), [chain, ctx, handler](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
+    safe_chain(chain).fetch_block(height, [chain, ctx, handler](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
         handler(chain, ctx, kth::to_c_err(ec), kth::leak_if_success(block, ec), h);
     });
 }
 
 void kth_chain_async_block_by_hash(kth_chain_t chain, void* ctx, kth_hash_t hash, kth_block_fetch_handler_t handler) {
     auto hash_cpp = kth::to_array(hash.hash);
-    safe_chain(chain).fetch_block(hash_cpp, kth::witness(), [chain, ctx, handler](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
+    safe_chain(chain).fetch_block(hash_cpp, [chain, ctx, handler](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
         handler(chain, ctx, kth::to_c_err(ec), kth::leak_if_success(block, ec), h);
     });
 }
@@ -140,7 +140,7 @@ void kth_chain_async_block_by_height_timestamp(kth_chain_t chain, void* ctx, kth
 void kth_chain_async_transaction(kth_chain_t chain, void* ctx, kth_hash_t hash, kth_bool_t require_confirmed, kth_transaction_fetch_handler_t handler) {
     //precondition:  [hash, 32] is a valid range
     auto hash_cpp = kth::to_array(hash.hash);
-    safe_chain(chain).fetch_transaction(hash_cpp, kth::int_to_bool(require_confirmed), kth::witness(), [chain, ctx, handler](std::error_code const& ec, kth::domain::message::transaction::const_ptr transaction, size_t i, size_t h) {
+    safe_chain(chain).fetch_transaction(hash_cpp, kth::int_to_bool(require_confirmed), [chain, ctx, handler](std::error_code const& ec, kth::domain::message::transaction::const_ptr transaction, size_t i, size_t h) {
         handler(chain, ctx, kth::to_c_err(ec), kth::leak_if_success(transaction, ec), i, h);
     });
 }

src/chain/chain_sync.cpp

@@ -120,7 +120,7 @@ kth_error_code_t kth_chain_sync_block_by_height(kth_chain_t chain, kth_size_t he
     std::latch latch(1); //Note: workaround to fix an error on some versions of Boost.Threads
     kth_error_code_t res;
 
-    safe_chain(chain).fetch_block(height, kth::witness(), [&](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
+    safe_chain(chain).fetch_block(height, [&](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
         if (ec == kth::error::success) {
             *out_block = kth::leak_if_success(block, ec);
         } else {
@@ -142,7 +142,7 @@ kth_error_code_t kth_chain_sync_block_by_hash(kth_chain_t chain, kth_hash_t hash
 
     auto hash_cpp = kth::to_array(hash.hash);
 
-    safe_chain(chain).fetch_block(hash_cpp, kth::witness(), [&](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
+    safe_chain(chain).fetch_block(hash_cpp, [&](std::error_code const& ec, kth::domain::message::block::const_ptr block, size_t h) {
         if (ec == kth::error::success) {
             *out_block = kth::leak_if_success(block, ec);
         } else {
@@ -280,7 +280,7 @@ kth_error_code_t kth_chain_sync_transaction(kth_chain_t chain, kth_hash_t hash,
 
     auto hash_cpp = kth::to_array(hash.hash);
 
-    safe_chain(chain).fetch_transaction(hash_cpp, kth::int_to_bool(require_confirmed), kth::witness(), [&](std::error_code const& ec, kth::domain::message::transaction::const_ptr transaction, size_t i, size_t h) {
+    safe_chain(chain).fetch_transaction(hash_cpp, kth::int_to_bool(require_confirmed), [&](std::error_code const& ec, kth::domain::message::transaction::const_ptr transaction, size_t i, size_t h) {
         *out_transaction = kth::leak_if_success(transaction, ec);
         *out_height = h;
         *out_index = i;
@@ -375,7 +375,7 @@ kth_error_code_t kth_chain_sync_confirmed_transactions(kth_chain_t chain, kth_pa
 kth_mempool_transaction_list_t kth_chain_sync_mempool_transactions(kth_chain_t chain, kth_payment_address_t address, kth_bool_t use_testnet_rules) {
     auto const& address_cpp = kth_wallet_payment_address_const_cpp(address);
     if (address_cpp) {
-        auto txs = safe_chain(chain).get_mempool_transactions(address_cpp.encoded_cashaddr(false), kth::int_to_bool(use_testnet_rules), kth::witness());
+        auto txs = safe_chain(chain).get_mempool_transactions(address_cpp.encoded_cashaddr(false), kth::int_to_bool(use_testnet_rules));
         auto ret_txs = kth::leak(txs);
         return static_cast<kth_mempool_transaction_list_t>(ret_txs);
     }
@@ -385,7 +385,7 @@ kth_mempool_transaction_list_t kth_chain_sync_mempool_transactions(kth_chain_t c
 
 kth_transaction_list_t kth_chain_sync_mempool_transactions_from_wallets(kth_chain_t chain, kth_payment_address_list_t addresses, kth_bool_t use_testnet_rules) {
     auto const& addresses_cpp = *static_cast<std::vector<kth::domain::wallet::payment_address> const*>(addresses);
-    auto txs = safe_chain(chain).get_mempool_transactions_from_wallets(addresses_cpp, kth::int_to_bool(use_testnet_rules), kth::witness());
+    auto txs = safe_chain(chain).get_mempool_transactions_from_wallets(addresses_cpp, kth::int_to_bool(use_testnet_rules));
     return kth::move_or_copy_and_leak(std::move(txs));
 }
 

src/chain/header.cpp

@@ -13,7 +13,7 @@ extern "C" {
 
 kth_header_t kth_chain_header_factory_from_data(uint8_t* data, kth_size_t n) {
     kth::data_chunk data_cpp(data, std::next(data, n));
-    auto header = kth::domain::create<kth::domain::chain::header>(data_cpp);
+    auto header = kth::domain::create_old<kth::domain::chain::header>(data_cpp);
     return kth::move_or_copy_and_leak(std::move(header));
 }
 

src/chain/input.cpp

@@ -29,7 +29,7 @@ void kth_chain_input_destruct(kth_input_t input) {
 
 kth_input_t kth_chain_input_factory_from_data(uint8_t* data, kth_size_t n) {
     kth::data_chunk data_cpp(data, std::next(data, n));
-    auto input = kth::domain::create<kth::domain::chain::input>(data_cpp);
+    auto input = kth::domain::create_old<kth::domain::chain::input>(data_cpp, true);
     return kth::move_or_copy_and_leak(std::move(input));
 }
 

src/chain/output.cpp

@@ -98,7 +98,7 @@ void kth_chain_output_destruct(kth_output_t output) {
 
 kth_output_t kth_chain_output_factory_from_data(uint8_t* data, kth_size_t n) {
     kth::data_chunk data_cpp(data, std::next(data, n));
-    auto output = kth::domain::create<kth::domain::chain::output>(data_cpp);
+    auto output = kth::domain::create_old<kth::domain::chain::output>(data_cpp);
     return kth::move_or_copy_and_leak(std::move(output));
 }
 

src/chain/transaction.cpp

@@ -18,7 +18,7 @@ extern "C" {
 
 kth_transaction_t kth_chain_transaction_factory_from_data(uint8_t* data, kth_size_t n) {
     kth::data_chunk data_cpp(data, std::next(data, n));
-    auto tx = kth::domain::create<kth::domain::chain::transaction>(data_cpp);
+    auto tx = kth::domain::create_old<kth::domain::chain::transaction>(data_cpp);
     return kth::move_or_copy_and_leak(std::move(tx));
 }
 
@@ -58,15 +58,15 @@ void kth_chain_transaction_hash_out(kth_transaction_t transaction, kth_hash_t* o
     kth::copy_c_hash(hash_cpp, out_hash);
 }
 
-kth_hash_t kth_chain_transaction_hash_sighash_type(kth_transaction_t transaction, uint32_t sighash_type) {
-    auto const& hash_cpp = kth_chain_transaction_const_cpp(transaction).hash(sighash_type != 0u);
-    return kth::to_hash_t(hash_cpp);
-}
+// kth_hash_t kth_chain_transaction_hash_sighash_type(kth_transaction_t transaction, uint32_t sighash_type) {
+//     auto const& hash_cpp = kth_chain_transaction_const_cpp(transaction).hash(sighash_type != 0u);
+//     return kth::to_hash_t(hash_cpp);
+// }
 
-void kth_chain_transaction_hash_sighash_type_out(kth_transaction_t transaction, uint32_t sighash_type, kth_hash_t* out_hash) {
-    auto const& hash_cpp = kth_chain_transaction_const_cpp(transaction).hash(sighash_type != 0u);
-    kth::copy_c_hash(hash_cpp, out_hash);
-}
+// void kth_chain_transaction_hash_sighash_type_out(kth_transaction_t transaction, uint32_t sighash_type, kth_hash_t* out_hash) {
+//     auto const& hash_cpp = kth_chain_transaction_const_cpp(transaction).hash(sighash_type != 0u);
+//     kth::copy_c_hash(hash_cpp, out_hash);
+// }
 
 uint32_t kth_chain_transaction_locktime(kth_transaction_t transaction) {
     return kth_chain_transaction_const_cpp(transaction).locktime();