feat: refactor domain objects deserialization

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/operation.h

@@ -37,8 +37,8 @@ char const* kth_chain_operation_to_string(kth_operation_t operation, uint32_t ac
 KTH_EXPORT
 uint8_t const* kth_chain_operation_to_data(kth_operation_t operation, kth_size_t* out_size);
 
-KTH_EXPORT
-kth_bool_t kth_chain_operation_from_data_mutable(kth_operation_t operation, uint8_t const* data, kth_size_t n);
+// KTH_EXPORT
+// kth_bool_t kth_chain_operation_from_data_mutable(kth_operation_t operation, uint8_t const* data, kth_size_t n);
 
 KTH_EXPORT
 kth_bool_t kth_chain_operation_from_string_mutable(kth_operation_t operation, char const* value);

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

@@ -20,14 +20,13 @@ kth_block_t kth_chain_block_construct_default() {
 
 kth_block_t kth_chain_block_construct(kth_header_t header, kth_transaction_list_t transactions) {
     auto const& header_cpp = kth_chain_header_const_cpp(header);
-    // auto const& txs_cpp = *static_cast<kth::domain::chain::transaction::list const*>(transactions);
     auto const& txs_cpp = kth_chain_transaction_list_const_cpp(transactions);
     return new kth::domain::chain::block(header_cpp, txs_cpp);
 }
 
 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/operation.cpp

@@ -46,19 +46,14 @@ uint8_t const* kth_chain_operation_to_data(kth_operation_t operation, kth_size_t
     return kth::create_c_array(operation_data, *out_size);
 }
 
-kth_bool_t kth_chain_operation_from_data_mutable(kth_operation_t operation, uint8_t const* data, kth_size_t n) {
-    kth::data_chunk data_cpp(data, std::next(data, n));
-    auto& op_cpp = kth_chain_operation_cpp(operation);
-    auto const res = kth::domain::entity_from_data(op_cpp, data_cpp);
-    return kth::bool_to_int(res);
-}
+// kth_bool_t kth_chain_operation_from_data_mutable(kth_operation_t operation, uint8_t const* data, kth_size_t n) {
+//     kth::data_chunk data_cpp(data, std::next(data, n));
+//     auto& op_cpp = kth_chain_operation_cpp(operation);
+//     auto const res = kth::domain::entity_from_data(op_cpp, data_cpp);
+//     return kth::bool_to_int(res);
+// }
 
 kth_bool_t kth_chain_operation_from_string_mutable(kth_operation_t operation, char const* value) {
-
-    // auto script = new kth::domain::chain::script();
-    // script->from_string(std::string(str));
-    // return script;
-
     auto& op_cpp = kth_chain_operation_cpp(operation);
     auto const res = op_cpp.from_string(std::string(value));
     return kth::bool_to_int(res);

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/token_data.cpp

@@ -75,13 +75,13 @@ kth_bool_t kth_chain_token_data_is_valid(kth_token_data_t token_data) {
 }
 
 kth_size_t kth_chain_token_data_serialized_size(kth_token_data_t token_data) {
-    return kth::domain::chain::encoding::serialized_size(
+    return kth::domain::chain::token::encoding::serialized_size(
             kth_chain_token_data_const_cpp(token_data)
         );
 }
 
 uint8_t const* kth_chain_token_data_to_data(kth_token_data_t token_data, kth_size_t* out_size) {
-    auto token_data_data = kth::domain::chain::encoding::to_data(kth_chain_token_data_const_cpp(token_data));
+    auto token_data_data = kth::domain::chain::token::encoding::to_data(kth_chain_token_data_const_cpp(token_data));
     return kth::create_c_array(token_data_data, *out_size);
 }
 

src/chain/transaction.cpp

@@ -18,8 +18,12 @@ 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);
-    return kth::move_or_copy_and_leak(std::move(tx));
+    kth::byte_reader reader(data_cpp);
+    auto obj = kth::domain::chain::transaction::from_data(reader, true);
+    if ( ! obj) {
+        return nullptr;
+    }
+    return kth::move_or_copy_and_leak(std::move(obj.value()));
 }
 
 kth_transaction_t kth_chain_transaction_construct_default() {
@@ -58,15 +62,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();