From 8ce303b2eff26009b97bb10f78d9b8081ed64036 Mon Sep 17 00:00:00 2001
From: Roman Khlopkov <roman.khlopkov@demlabs.net>
Date: Fri, 18 Mar 2022 19:30:06 +0000
Subject: [PATCH] support-5341++
---
dap-sdk/core/include/dap_common.h | 4 +-
dap-sdk/crypto/include/dap_cert.h | 2 +-
dap-sdk/crypto/src/dap_cert.c | 4 +-
dap-sdk/net/client/dap_client.c | 8 +-
modules/chain/dap_chain_ledger.c | 212 +++++++++---------
modules/chain/include/dap_chain_ledger.h | 2 +-
.../dap_stream_ch_chain_net_srv.c | 4 +-
modules/common/dap_chain_datum_tx_items.c | 9 +-
.../common/include/dap_chain_datum_tx_in.h | 4 -
.../common/include/dap_chain_datum_tx_items.h | 2 +-
.../dap_chain_global_db_driver_cdb.c | 34 ++-
modules/global-db/dap_chain_global_db_hist.c | 11 +-
modules/mempool/dap_chain_mempool.c | 8 +-
modules/net/dap_chain_net.c | 43 +---
.../service/stake/dap_chain_net_srv_stake.c | 4 +-
15 files changed, 158 insertions(+), 193 deletions(-)
diff --git a/dap-sdk/core/include/dap_common.h b/dap-sdk/core/include/dap_common.h
index 6dcdcd59b2..548cdc5210 100755
--- a/dap-sdk/core/include/dap_common.h
+++ b/dap-sdk/core/include/dap_common.h
@@ -138,12 +138,12 @@ typedef uint8_t byte_t;
#define DAP_NEW_Z( a ) DAP_CAST_REINT(a, calloc(1,sizeof(a)))
#define DAP_NEW_Z_SIZE(a, b) DAP_CAST_REINT(a, calloc(1,b))
#define DAP_REALLOC(a, b) realloc(a,b)
- #define DAP_DELETE(a) free(a)
+ #define DAP_DELETE(a) free((void *)a)
#define DAP_DUP(a) memcpy(malloc(sizeof(*a)), a, sizeof(*a))
#define DAP_DUP_SIZE(a, s) memcpy(malloc(s), a, s)
#endif
-#define DAP_DEL_Z(a) if (a) { DAP_DELETE(a); (a) = NULL; }
+#define DAP_DEL_Z(a) if (a) { DAP_DELETE((void *)a); (a) = NULL; }
DAP_STATIC_INLINE void *_dap_aligned_alloc( uintptr_t alignment, uintptr_t size )
{
diff --git a/dap-sdk/crypto/include/dap_cert.h b/dap-sdk/crypto/include/dap_cert.h
index ee526e8649..9a7cf3dcbd 100755
--- a/dap-sdk/crypto/include/dap_cert.h
+++ b/dap-sdk/crypto/include/dap_cert.h
@@ -81,7 +81,7 @@ void dap_cert_add_folder(const char *a_folder_path);
void dap_cert_dump(dap_cert_t * a_cert);
dap_pkey_t * dap_cert_to_pkey(dap_cert_t * a_cert);
-dap_cert_t * dap_cert_find_by_name(const char * a_cert_name);
+dap_cert_t *dap_cert_find_by_name(const char *a_cert_name);
dap_list_t *dap_cert_get_all_mem();
dap_sign_t * dap_cert_sign(dap_cert_t * a_cert, const void * a_data, size_t a_data_size, size_t a_output_size_wished );
diff --git a/dap-sdk/crypto/src/dap_cert.c b/dap-sdk/crypto/src/dap_cert.c
index b9e24a29d6..8dc40c764c 100755
--- a/dap-sdk/crypto/src/dap_cert.c
+++ b/dap-sdk/crypto/src/dap_cert.c
@@ -293,8 +293,10 @@ void dap_cert_delete_by_name(const char * a_cert_name)
* @param a_cert_name const char *
* @return
*/
-dap_cert_t * dap_cert_find_by_name(const char * a_cert_name)
+dap_cert_t *dap_cert_find_by_name(const char *a_cert_name)
{
+ if (!a_cert_name)
+ return NULL;
dap_cert_item_t *l_cert_item = NULL;
dap_cert_t *l_ret = NULL;
HASH_FIND_STR(s_certs, a_cert_name, l_cert_item);
diff --git a/dap-sdk/net/client/dap_client.c b/dap-sdk/net/client/dap_client.c
index cda4e104fd..cb55dd92e9 100644
--- a/dap-sdk/net/client/dap_client.c
+++ b/dap-sdk/net/client/dap_client.c
@@ -195,27 +195,23 @@ void dap_client_set_auth_cert_unsafe(dap_client_t * a_client, dap_cert_t *a_cert
*/
void dap_client_set_auth_cert(dap_client_t *a_client, const char *a_chain_net_name)
{
- const char *l_auth_hash_str = NULL;
-
if(a_client == NULL || a_chain_net_name == NULL){
log_it(L_ERROR,"Chain-net is NULL for dap_client_set_auth_cert");
return;
}
-
char *l_path = dap_strdup_printf("network/%s", a_chain_net_name);
if (!l_path) {
log_it(L_ERROR, "Can't allocate memory: file: %s line: %d", __FILE__, __LINE__);
return;
}
-
dap_config_t *l_cfg = dap_config_open(l_path);
free(l_path);
if (!l_cfg) {
log_it(L_ERROR, "Can't allocate memory: file: %s line: %d", __FILE__, __LINE__);
return;
}
-
- dap_cert_t *l_cert = dap_cert_find_by_name(dap_config_get_item_str(l_cfg, "general", "auth_cert"));
+ const char *l_cert_name = dap_config_get_item_str(l_cfg, "general", "auth_cert");
+ dap_cert_t *l_cert = l_cert_name ? dap_cert_find_by_name(l_cert_name) : NULL;
if (!l_cert) {
dap_config_close(l_cfg);
log_it(L_ERROR,"l_cert is NULL by dap_cert_find_by_name");
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 6e1b6d174d..129781cf75 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -1060,6 +1060,8 @@ static void s_threshold_emissions_proc(dap_ledger_t * a_ledger)
pthread_rwlock_wrlock(&PVT(a_ledger)->threshold_emissions_rwlock);
HASH_DEL(PVT(a_ledger)->threshold_emissions, l_emission_item);
pthread_rwlock_unlock(&PVT(a_ledger)->threshold_emissions_rwlock);
+ if (l_res)
+ DAP_DELETE(l_emission_item->datum_token_emission);
DAP_DELETE(l_emission_item);
l_success = true;
}
@@ -1089,6 +1091,8 @@ static void s_threshold_txs_proc( dap_ledger_t *a_ledger)
if (l_res != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION &&
l_res != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS) {
HASH_DEL(l_ledger_pvt->threshold_txs, l_tx_item);
+ if (l_res != 1)
+ DAP_DELETE(l_tx_item->tx);
DAP_DELETE(l_tx_item);
l_success = true;
}
@@ -1158,6 +1162,7 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
l_objs_count = 0;
+ //uint8_t *l_result = dap_chain_global_db_gr_get("0xFB0770E29B59D588EF9FE0DAF6A9E9A14739797023C9C598C9708C8FC4922385", &l_objs_count, l_gdb_group);
l_objs = dap_chain_global_db_gr_load(l_gdb_group, &l_objs_count);
for (size_t i = 0; i < l_objs_count; i++) {
dap_chain_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
@@ -1263,7 +1268,7 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
: &l_ledger_priv->threshold_emissions_rwlock);
if(l_token_emission_item ) {
if(s_debug_more) {
- if ( l_token_emission_item->datum_token_emission->hdr.version == 1 ) //&& l_token_emission_item->datum_token_emission->hdr.type_256 )
+ if ( l_token_emission_item->datum_token_emission->hdr.version == 2 )
log_it(L_ERROR, "Can't add token emission datum of %s %s ( %s ): already present in cache",
dap_chain_balance_print(l_token_emission_item->datum_token_emission->hdr.value_256), c_token_ticker, l_hash_str);
else
@@ -1360,21 +1365,18 @@ bool s_chain_ledger_token_tsd_check(dap_ledger_t *a_ledger, dap_chain_ledger_tok
if (!l_tsd)
return false;
switch(l_tsd->type){
- case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
-
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD: {
//s_token_tsd_parse(a_ledger, l_token_item , l_token_item->datum_token, l_token_item->datum_token_size);
dap_chain_addr_t * l_add_addr = (dap_chain_addr_t *) l_tsd->data;
-
- if (!s_chain_compare_token_addresses(&a_token_emission->hdr.address, l_add_addr)){
- log_it(L_WARNING, "address %s is not allowed for emission for token %s", dap_chain_addr_to_str(&a_token_emission->hdr.address), l_token_item->ticker);
- return false;
- }
-
- break;
- default:
- break;
+ if (!s_chain_compare_token_addresses(&a_token_emission->hdr.address, l_add_addr)){
+ log_it(L_WARNING, "Address %s is not allowed for emission for token %s",
+ dap_chain_addr_to_str(&a_token_emission->hdr.address), l_token_item->ticker);
+ return false;
+ }
+ } break;
+ default: break;
}
- log_it(L_WARNING, "private tokens limitations were checked successful");
+ log_it(L_WARNING, "Private tokens limitations were checked successful");
return true;
}
@@ -1462,6 +1464,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
c_token_ticker, l_token_emission_address_str);
DAP_DELETE(l_token_emission_address_str);
}
+ s_threshold_txs_proc(a_ledger);
} else if (HASH_COUNT(l_ledger_priv->threshold_emissions) < s_threshold_emissions_max) {
l_token_emission_item->datum_token_emission = DAP_DUP_SIZE(a_token_emission, a_token_emission_size);
pthread_rwlock_wrlock(&l_ledger_priv->threshold_emissions_rwlock);
@@ -1793,7 +1796,7 @@ static int s_ledger_permissions_check(dap_chain_ledger_token_item_t * a_token_i
*/
// Checking a new transaction before adding to the cache
int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
- dap_list_t **a_list_bound_items, dap_list_t **a_list_tx_out)
+ bool a_from_threshold, dap_list_t **a_list_bound_items, dap_list_t **a_list_tx_out)
{
/*
Steps of checking for current transaction tx2 and every previous transaction tx1:
@@ -1845,6 +1848,10 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
dap_list_free(l_list_tmp);
}
l_list_tmp = l_list_in;
+ if (!l_list_in) {
+ log_it(L_WARNING, "Tx check: no valid inputs found");
+ return -22;
+ }
dap_chain_ledger_tx_bound_t *bound_item;
int l_list_tmp_num = 0;
// find all previous transactions
@@ -1902,12 +1909,12 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
s_find_datum_tx_by_hash(a_ledger, &l_tx_prev_hash, &l_item_out); // dap_chain_datum_tx_t *l_tx_prev = (dap_chain_datum_tx_t*) dap_chain_node_datum_tx_cache_find(&tx_prev_hash);
bound_item->item_out = l_item_out;
if(!l_tx_prev) { // Unchained transaction
- //if(s_debug_more) // Too many messages with thresholds processing
- // log_it(L_DEBUG,"No previous transaction was found for hash %s",l_tx_prev_hash_str);
+ if (s_debug_more && !a_from_threshold)
+ log_it(L_DEBUG, "No previous transaction was found for hash %s", l_tx_prev_hash_str);
l_err_num = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS;
break;
}
- if(s_debug_more)
+ if (s_debug_more && !a_from_threshold)
log_it(L_INFO,"Previous transaction was found for hash %s",l_tx_prev_hash_str);
bound_item->tx_prev = l_tx_prev;
@@ -2103,7 +2110,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
strcpy(l_value_cur->token_ticker, l_token);
HASH_ADD_STR(l_values_from_prev_tx, token_ticker, l_value_cur);
}
- // calculate sum of values from previous transactions per each token
+ // calculate from previous transactions per each token
SUM_256_256(l_value_cur->sum, l_value, &l_value_cur->sum);
l_list_bound_items = dap_list_append(l_list_bound_items, bound_item);
@@ -2135,7 +2142,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
dap_list_t *l_list_tx_out = NULL;
- bool l_emission_flag = !l_is_first_transaction || (l_is_first_transaction && l_ledger_priv->check_token_emission);
// find 'out' items
dap_list_t *l_list_out = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
uint256_t l_value = {};
@@ -2149,9 +2155,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_err_num = -16;
break;
}
- if (l_emission_flag) {
- l_value = dap_chain_uint256_from(l_tx_out->header.value);
- }
+ l_value = dap_chain_uint256_from(l_tx_out->header.value);
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
} break;
@@ -2161,9 +2165,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_err_num = -16;
break;
}
- if (l_emission_flag) {
- l_value = l_tx_out->header.value;
- }
+ l_value = l_tx_out->header.value;
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
} break;
@@ -2173,23 +2175,19 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_err_num = -16;
break;
}
- if (l_emission_flag) {
- l_value = l_tx_out->header.value;
- l_token = l_tx_out->token;
- }
+ l_value = l_tx_out->header.value;
+ l_token = l_tx_out->token;
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
} break;
case TX_ITEM_TYPE_OUT_COND: {
dap_chain_tx_out_cond_t *l_tx_out = (dap_chain_tx_out_cond_t *)l_list_tmp->data;
- if (l_emission_flag) {
- l_value = l_tx_out->header.value;
- }
if (l_multichannel) { // out_cond have no field .token
log_it(L_WARNING, "No conditional output support for multichannel transaction");
l_err_num = -18;
break;
}
+ l_value = l_tx_out->header.value;
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
} break;
default: {}
@@ -2249,33 +2247,33 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
if ( l_list_out )
dap_list_free(l_list_out);
- // Additional check whether the transaction is first
- if (l_is_first_transaction && !l_err_num) {
- if (l_ledger_priv->check_token_emission) { // Check the token emission
- dap_chain_datum_token_emission_t * l_token_emission = dap_chain_ledger_token_emission_find(a_ledger, l_token, l_emission_hash);
- if (l_token_emission) {
- if (!EQUAL_256(l_token_emission->hdr.value_256, l_value_cur->sum)) {
- l_err_num = -10;
+ // Check for transaction consistency (sum(ins) == sum(outs))
+ if (!l_err_num) {
+ if (l_is_first_transaction) {
+ if (l_ledger_priv->check_token_emission) { // Check the token emission
+ dap_chain_datum_token_emission_t * l_token_emission = dap_chain_ledger_token_emission_find(a_ledger, l_token, l_emission_hash);
+ if (l_token_emission) {
+ if (!EQUAL_256(l_token_emission->hdr.value_256, l_value_cur->sum)) {
+ l_err_num = -10;
+ }
+ l_value_cur = NULL;
+ } else {
+ log_it(L_WARNING, "Emission for tx_token wasn't found");
+ l_err_num = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION;
}
- l_value_cur = NULL;
- } else {
- log_it(L_WARNING, "Emission for tx_token wasn't found");
- l_err_num = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION;
}
- }
- }
- if (!l_is_first_transaction && !l_err_num) {
- HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
- HASH_FIND_STR(l_values_from_cur_tx, l_value_cur->token_ticker, l_res);
- if (!l_res || !EQUAL_256(l_res->sum, l_value_cur->sum) ) {
- if(s_debug_more)
- log_it(L_ERROR, "Sum of values in out items of current tx 256 (%s) is not equal outs from previous tx (%s) for token %s",
- dap_chain_balance_print(l_res ? l_res->sum : uint256_0), dap_chain_balance_print(l_value_cur->sum), l_value_cur->token_ticker);
- l_err_num = -12;
- break;
+ } else {
+ HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
+ HASH_FIND_STR(l_values_from_cur_tx, l_value_cur->token_ticker, l_res);
+ if (!l_res || !EQUAL_256(l_res->sum, l_value_cur->sum) ) {
+ if(s_debug_more)
+ log_it(L_ERROR, "Sum of values of out items from current tx 256 (%s) is not equal outs from previous tx (%s) for token %s",
+ dap_chain_balance_print(l_res ? l_res->sum : uint256_0), dap_chain_balance_print(l_value_cur->sum), l_value_cur->token_ticker);
+ l_err_num = -12;
+ break;
+ }
}
}
-
}
HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
@@ -2313,7 +2311,7 @@ int dap_chain_ledger_tx_add_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *
int l_ret_check;
if( (l_ret_check = dap_chain_ledger_tx_cache_check(
- a_ledger, a_tx, &l_list_bound_items, &l_list_tx_out)) < 0){
+ a_ledger, a_tx, false, &l_list_bound_items, &l_list_tx_out)) < 0){
if(s_debug_more)
log_it (L_DEBUG, "dap_chain_ledger_tx_add_check() tx not passed the check: code %d ",l_ret_check);
return l_ret_check;
@@ -2340,32 +2338,6 @@ static int s_balance_cache_update(dap_ledger_t *a_ledger, dap_ledger_wallet_bala
return 0;
}
-static int s_tx_cache_update(dap_ledger_t *a_ledger, dap_chain_ledger_tx_item_t *a_item)
-{
- int rc;
-
- size_t l_tx_size = dap_chain_datum_tx_get_size(a_item->tx),
- l_tx_cache_sz = l_tx_size + sizeof(a_item->cache_data);
-
- uint8_t *l_tx_cache = DAP_NEW_Z_SIZE(uint8_t, l_tx_cache_sz);
- memcpy(l_tx_cache, &a_item->cache_data, sizeof(a_item->cache_data));
- memcpy(l_tx_cache + sizeof(a_item->cache_data), a_item->tx, l_tx_size);
-
- char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
- char *l_tx_hash_str = dap_chain_hash_fast_to_str_new(&a_item->tx_hash_fast);
-
- if ( !(rc = dap_chain_global_db_gr_set(l_tx_hash_str, l_tx_cache, l_tx_cache_sz, l_gdb_group)) ) {
- if(s_debug_more)
- log_it(L_WARNING, "Ledger cache mismatch");
- }
-
- DAP_DELETE(l_tx_hash_str);
- DAP_DELETE(l_tx_cache);
- DAP_DELETE(l_gdb_group);
-
- return (rc == true) ? 0 : -1;
-}
-
/**
* Add new transaction to the cache list
*
@@ -2393,7 +2365,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
l_ledger_priv->tps_timer = dap_timerfd_start(500, s_ledger_tps_callback, l_ledger_priv);
}
bool l_from_threshold = a_from_threshold;
- if (!l_ledger_priv->load_mode && !l_from_threshold) {
+ if (!l_ledger_priv->load_mode && !a_from_threshold) {
HASH_VALUE(a_tx_hash, sizeof(*a_tx_hash), l_hash_value);
pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
HASH_FIND_BYHASHVALUE(hh, l_ledger_priv->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_hash_value, l_item_tmp);
@@ -2410,8 +2382,9 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
int l_ret_check;
l_item_tmp = NULL;
if( (l_ret_check = dap_chain_ledger_tx_cache_check(
- a_ledger, a_tx, &l_list_bound_items, &l_list_tx_out)) < 0) {
- if (l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS) {
+ a_ledger, a_tx, a_from_threshold, &l_list_bound_items, &l_list_tx_out)) < 0) {
+ if (l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS ||
+ l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION) {
if (!l_from_threshold) {
if (!l_hash_value)
HASH_VALUE(a_tx_hash, sizeof(*a_tx_hash), l_hash_value);
@@ -2421,12 +2394,12 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
if (!l_item_tmp) {
if (l_threshold_txs_count >= s_threshold_txs_max) {
if(s_debug_more)
- log_it(L_WARNING,"threshold for tranactions is overfulled (%zu max), dropping down new data, added nothing",
+ log_it(L_WARNING, "Threshold for tranactions is overfulled (%zu max), dropping down new data, added nothing",
s_threshold_txs_max);
} else {
l_item_tmp = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
memcpy(&l_item_tmp->tx_hash_fast, a_tx_hash, sizeof(dap_chain_hash_fast_t));
- l_item_tmp->tx = a_tx;
+ l_item_tmp->tx = DAP_DUP_SIZE(a_tx, dap_chain_datum_tx_get_size(a_tx));
HASH_ADD_BYHASHVALUE(hh, l_ledger_priv->threshold_txs, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_hash_value, l_item_tmp);
if(s_debug_more)
log_it (L_DEBUG, "Tx %s added to threshold", l_tx_hash_str);
@@ -2451,10 +2424,15 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
// Mark 'out' items in cache if they were used & delete previous transactions from cache if it need
// find all bound pairs 'in' and 'out'
dap_list_t *l_list_tmp = l_list_bound_items;
+ size_t l_outs_used = dap_list_length(l_list_bound_items);
+ size_t l_cache_size = sizeof(dap_store_obj_t) * (l_outs_used + 1);
+ dap_store_obj_t *l_cache_used_outs = DAP_NEW_S_SIZE(dap_store_obj_t, l_cache_size);
+ memset(l_cache_used_outs, 0, l_cache_size);
+ char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
char *l_ticker_trl = NULL, *l_ticker_old_trl = NULL;
bool l_stake_updated = false;
// Update balance: deducts
- while(l_list_tmp) {
+ for (int i = 1; l_list_tmp; i++) {
dap_chain_ledger_tx_bound_t *bound_item = l_list_tmp->data;
void *l_item_in = *(void **)&bound_item->in;
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_item_in;
@@ -2538,7 +2516,16 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
memcpy(&(l_prev_item_out->cache_data.tx_hash_spent_fast[l_tx_prev_out_used_idx]), a_tx_hash, sizeof(dap_chain_hash_fast_t));
l_prev_item_out->cache_data.n_outs_used++;
// mirror it in the cache
- s_tx_cache_update(a_ledger, l_prev_item_out);
+ size_t l_tx_size = dap_chain_datum_tx_get_size(l_prev_item_out->tx);
+ size_t l_tx_cache_sz = l_tx_size + sizeof(l_prev_item_out->cache_data);
+ uint8_t *l_tx_cache = DAP_NEW_S_SIZE(uint8_t, l_tx_cache_sz);
+ memcpy(l_tx_cache, &l_prev_item_out->cache_data, sizeof(l_prev_item_out->cache_data));
+ memcpy(l_tx_cache + sizeof(l_prev_item_out->cache_data), l_prev_item_out->tx, l_tx_size);
+ char *l_tx_hash_str = dap_chain_hash_fast_to_str_new(&l_prev_item_out->tx_hash_fast);
+ l_cache_used_outs[i].key = l_tx_hash_str;
+ l_cache_used_outs[i].value = l_tx_cache;
+ l_cache_used_outs[i].value_len = l_tx_cache_sz;
+ l_cache_used_outs[i].group = l_gdb_group;
// delete previous transactions from cache because all out is used
if(l_prev_item_out->cache_data.n_outs_used == l_prev_item_out->cache_data.n_outs) {
@@ -2584,7 +2571,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
//Update balance : raise
for (dap_list_t *l_tx_out = l_list_tx_out; l_tx_out; l_tx_out = dap_list_next(l_tx_out)) {
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_tx_out->data;
- if (l_type == TX_ITEM_TYPE_OUT_COND_OLD) {
+ if (l_type == TX_ITEM_TYPE_OUT_COND) {
// Update stakes if any
dap_chain_tx_out_cond_t *l_cond = (dap_chain_tx_out_cond_t *)l_tx_out->data;
if (l_cond->header.subtype == DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE && !l_stake_updated) {
@@ -2676,15 +2663,16 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
// add transaction to the cache list
if(ret == 1){
- l_item_tmp = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
- memcpy(&l_item_tmp->tx_hash_fast, a_tx_hash, sizeof(dap_chain_hash_fast_t));
- l_item_tmp->tx = DAP_NEW_SIZE(dap_chain_datum_tx_t, dap_chain_datum_tx_get_size(a_tx));
- l_item_tmp->cache_data.ts_created = time(NULL); // Time of transasction added to ledger
- dap_list_t *l_tist_tmp = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_ALL, &l_item_tmp->cache_data.n_outs);
+ dap_chain_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
+ memcpy(&l_tx_item->tx_hash_fast, a_tx_hash, sizeof(dap_chain_hash_fast_t));
+ size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
+ l_tx_item->tx = DAP_DUP_SIZE(a_tx, l_tx_size);
+ l_tx_item->cache_data.ts_created = time(NULL); // Time of transasction added to ledger
+ dap_list_t *l_tist_tmp = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_ALL, &l_tx_item->cache_data.n_outs);
// If debug mode dump the UTXO
if (dap_log_level_get() == L_DEBUG && s_debug_more) {
dap_list_t *it = l_tist_tmp;
- for (int i = 0; i < l_item_tmp->cache_data.n_outs; i++) {
+ for (int i = 0; i < l_tx_item->cache_data.n_outs; i++) {
dap_chain_tx_out_old_t *l_tx_out = it->data;
if (l_tx_out->header.type != TX_ITEM_TYPE_OUT_OLD)
continue;
@@ -2705,32 +2693,35 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
: NULL;
}
if (l_ticker_trl && !l_multichannel)
- dap_stpcpy(l_item_tmp->cache_data.token_ticker, l_token_ticker);
+ dap_stpcpy(l_tx_item->cache_data.token_ticker, l_token_ticker);
- size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
- memcpy(l_item_tmp->tx, a_tx, l_tx_size);
if (!l_hash_value)
HASH_VALUE(a_tx_hash, sizeof(*a_tx_hash), l_hash_value);
pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
- HASH_ADD_BYHASHVALUE(hh, l_ledger_priv->ledger_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_hash_value, l_item_tmp); // tx_hash_fast: name of key field
+ HASH_ADD_BYHASHVALUE(hh, l_ledger_priv->ledger_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_hash_value, l_tx_item); // tx_hash_fast: name of key field
pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
// Count TPS
clock_gettime(CLOCK_REALTIME, &l_ledger_priv->tps_end_time);
l_ledger_priv->tps_count++;
// Add it to cache
- uint8_t *l_tx_cache = DAP_NEW_Z_SIZE(uint8_t, l_tx_size + sizeof(l_item_tmp->cache_data));
- memcpy(l_tx_cache, &l_item_tmp->cache_data, sizeof(l_item_tmp->cache_data));
- memcpy(l_tx_cache + sizeof(l_item_tmp->cache_data), a_tx, l_tx_size);
- char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
- if (!dap_chain_global_db_gr_set( l_tx_hash_str, l_tx_cache, l_tx_size + sizeof(l_item_tmp->cache_data), l_gdb_group)) {
+ size_t l_tx_cache_sz = l_tx_size + sizeof(l_tx_item->cache_data);
+ uint8_t *l_tx_cache = DAP_NEW_S_SIZE(uint8_t, l_tx_cache_sz);
+ memcpy(l_tx_cache, &l_tx_item->cache_data, sizeof(l_tx_item->cache_data));
+ memcpy(l_tx_cache + sizeof(l_tx_item->cache_data), a_tx, l_tx_size);
+ l_cache_used_outs[0].key = l_tx_hash_str;
+ l_cache_used_outs[0].value = l_tx_cache;
+ l_cache_used_outs[0].value_len = l_tx_cache_sz;
+ l_cache_used_outs[0].group = l_gdb_group;
+ // Apply it with single DB transaction
+ if (dap_chain_global_db_driver_add(l_cache_used_outs, l_outs_used + 1)) {
if(s_debug_more)
log_it(L_WARNING, "Ledger cache mismatch");
}
-
- DAP_DELETE(l_tx_cache);
+ for (int i = 1; i <= l_outs_used; i++)
+ DAP_DELETE(l_cache_used_outs[i].key);
DAP_DELETE(l_gdb_group);
if (!a_from_threshold)
- s_threshold_txs_proc(a_ledger); // TODO process thresholds only for non consensus chains
+ s_threshold_txs_proc(a_ledger);
ret = 1;
}
return ret;
@@ -2823,7 +2814,8 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
DAP_DELETE(l_tx_hash_str);
DAP_DELETE(l_gdb_group);
}
- // del struct for hash
+ // delete tx & its item
+ DAP_DELETE(l_item_tmp->tx);
DAP_DELETE(l_item_tmp);
}
else
@@ -3078,7 +3070,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_out_idx_tmp++) {
assert(l_list_tmp->data);
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_list_tmp->data;
- if (l_type == TX_ITEM_TYPE_OUT_COND_OLD) {
+ if (l_type == TX_ITEM_TYPE_OUT_COND_OLD || (l_type == TX_ITEM_TYPE_OUT_COND)) {
continue;
}
if (l_type == TX_ITEM_TYPE_OUT_OLD) {
diff --git a/modules/chain/include/dap_chain_ledger.h b/modules/chain/include/dap_chain_ledger.h
index 5a02d2c3a4..010eb2196b 100644
--- a/modules/chain/include/dap_chain_ledger.h
+++ b/modules/chain/include/dap_chain_ledger.h
@@ -148,7 +148,7 @@ void dap_chain_ledger_addr_get_token_ticker_all_fast(dap_ledger_t *a_ledger, dap
char *** a_tickers, size_t * a_tickers_size);
// Checking a new transaction before adding to the cache
-int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
+int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, bool a_from_threshold,
dap_list_t **a_list_bound_items, dap_list_t **a_list_tx_out);
diff --git a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
index 8cfcbf050d..eb6a5f64fe 100644
--- a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
+++ b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
@@ -186,7 +186,7 @@ static bool s_grace_period_control(dap_chain_net_srv_grace_t *a_grace)
if (!l_grace_start) {
int l_tx_out_cond_size =0;
l_tx_out_cond = (dap_chain_tx_out_cond_t *)
- dap_chain_datum_tx_item_get(l_tx, NULL, TX_ITEM_TYPE_OUT_COND_OLD, &l_tx_out_cond_size );
+ dap_chain_datum_tx_item_get(l_tx, NULL, TX_ITEM_TYPE_OUT_COND, &l_tx_out_cond_size );
if ( ! l_tx_out_cond ) { // No conditioned output
log_it( L_WARNING, "No conditioned output");
@@ -470,7 +470,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
}
int l_tx_out_cond_size =0;
l_tx_out_cond = (dap_chain_tx_out_cond_t *)dap_chain_datum_tx_item_get(l_usage->tx_cond, NULL,
- TX_ITEM_TYPE_OUT_COND_OLD, &l_tx_out_cond_size );
+ TX_ITEM_TYPE_OUT_COND, &l_tx_out_cond_size );
if ( ! l_tx_out_cond ){ // No conditioned output
l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_TX_COND_NO_COND_OUT ;
dap_stream_ch_pkt_write_unsafe( a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err) );
diff --git a/modules/common/dap_chain_datum_tx_items.c b/modules/common/dap_chain_datum_tx_items.c
index 3567cca790..dbb8480aa8 100644
--- a/modules/common/dap_chain_datum_tx_items.c
+++ b/modules/common/dap_chain_datum_tx_items.c
@@ -111,8 +111,7 @@ static size_t dap_chain_datum_tx_receipt_get_size(const dap_chain_datum_tx_recei
*/
dap_chain_tx_item_type_t dap_chain_datum_tx_item_get_type(const uint8_t *a_item)
{
- const dap_chain_tx_in_t *l_item_tx_in = (const dap_chain_tx_in_t*) a_item;
- dap_chain_tx_item_type_t type = (l_item_tx_in) ? l_item_tx_in->header.type : TX_ITEM_TYPE_ANY;
+ dap_chain_tx_item_type_t type = a_item ? *(dap_chain_tx_item_type_t *)a_item : TX_ITEM_TYPE_ANY;
return type;
}
@@ -366,8 +365,8 @@ uint8_t* dap_chain_datum_tx_item_get( dap_chain_datum_tx_t *a_tx, int *a_item_id
return NULL;
uint32_t l_tx_items_pos = 0, l_tx_items_size = a_tx->header.tx_items_size;
int l_item_idx = 0;
- while(l_tx_items_pos < l_tx_items_size) {
- uint8_t *l_item = a_tx->tx_items + l_tx_items_pos;
+ while (l_tx_items_pos < l_tx_items_size) {
+ uint8_t *l_item = a_tx->tx_items + l_tx_items_pos;
int l_item_size = dap_chain_datum_item_tx_get_size(l_item);
if(!l_item_size)
return NULL;
@@ -426,7 +425,7 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a
int l_prev_cond_idx = l_list_out_items ? 0 : -1;
dap_chain_tx_out_cond_t *l_res = NULL;
for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_prev_cond_idx++) {
- if (*(uint8_t *)l_list_tmp->data == TX_ITEM_TYPE_OUT_COND_OLD) {
+ if (*(uint8_t *)l_list_tmp->data == TX_ITEM_TYPE_OUT_COND) {
l_res = l_list_tmp->data;
break;
}
diff --git a/modules/common/include/dap_chain_datum_tx_in.h b/modules/common/include/dap_chain_datum_tx_in.h
index b9fcbc2801..d4e2bc68f3 100644
--- a/modules/common/include/dap_chain_datum_tx_in.h
+++ b/modules/common/include/dap_chain_datum_tx_in.h
@@ -37,11 +37,7 @@ typedef struct dap_chain_tx_in{
dap_chain_tx_item_type_t type; /// @param type @brief Transaction item type
dap_chain_hash_fast_t tx_prev_hash; /// @param tx_prev_hash @brief Hash of the previous transaction. 0 for generation TX
uint32_t tx_out_prev_idx; /// @param tx_prev_idx @brief Previous tx_out index. 0 for generation TX
-// dap_sign_type_t sig_type; /// Signature type
-// uint32_t sig_size; /// Signature size
} header; /// Only header's hash is used for verification
-// uint32_t seq_no; /// Sequence number, out of the header so could be changed during reorganization
-// uint8_t sig[]; /// @param sig @brief raw signatura dat
} DAP_ALIGN_PACKED dap_chain_tx_in_t;
typedef struct list_used_item {
diff --git a/modules/common/include/dap_chain_datum_tx_items.h b/modules/common/include/dap_chain_datum_tx_items.h
index 0e33c0ecf0..77ce4f9b05 100644
--- a/modules/common/include/dap_chain_datum_tx_items.h
+++ b/modules/common/include/dap_chain_datum_tx_items.h
@@ -60,7 +60,7 @@ DAP_STATIC_INLINE const char * dap_chain_datum_tx_item_type_to_str(dap_chain_tx_
case TX_ITEM_TYPE_TOKEN: return "TX_ITEM_TYPE_TOKEN";
case TX_ITEM_TYPE_TOKEN_EXT: return "TX_ITEM_TYPE_TOKEN_EXT";
case TX_ITEM_TYPE_IN_COND: return "TX_ITEM_TYPE_IN_COND";
- case TX_ITEM_TYPE_OUT_COND_OLD: return "TX_ITEM_TYPE_OUT_COND_OLD"; // 256
+ case TX_ITEM_TYPE_OUT_COND: return "TX_ITEM_TYPE_OUT_COND"; // 256
case TX_ITEM_TYPE_RECEIPT: return "TX_ITEM_TYPE_RECEIPT";
case TX_ITEM_TYPE_OUT_ALL: return "TX_ITEM_TYPE_OUT_OLDALL";
case TX_ITEM_TYPE_ANY: return "TX_ITEM_TYPE_ANY";
diff --git a/modules/global-db/dap_chain_global_db_driver_cdb.c b/modules/global-db/dap_chain_global_db_driver_cdb.c
index 0ce7d72601..4e1d0fd37d 100644
--- a/modules/global-db/dap_chain_global_db_driver_cdb.c
+++ b/modules/global-db/dap_chain_global_db_driver_cdb.c
@@ -177,14 +177,18 @@ pcdb_instance dap_cdb_init_group(const char *a_group, int a_flags) {
pthread_mutex_lock(&cdb_mutex);
char l_cdb_path[strlen(s_cdb_path) + strlen(a_group) + 2];
HASH_FIND_STR(s_cdb, a_group, l_cdb_i);
+ if (a_flags & CDB_TRUNC) {
+ if (!l_cdb_i)
+ goto FIN;
+ cdb_close(l_cdb_i->cdb);
+ }
if (!(a_flags & CDB_TRUNC)) {
if (l_cdb_i)
goto FIN;
l_cdb_i = DAP_NEW(cdb_instance);
+ l_cdb_i->local_group = dap_strdup(a_group);
+ l_cdb_i->cdb = cdb_new();
}
- l_cdb_i = DAP_NEW(cdb_instance);
- l_cdb_i->local_group = dap_strdup(a_group);
- l_cdb_i->cdb = cdb_new();
memset(l_cdb_path, '\0', sizeof(l_cdb_path));
dap_snprintf(l_cdb_path, sizeof(l_cdb_path), "%s/%s", s_cdb_path, a_group);
cdb_options l_opts = { 1000000, 128, 1024 };
@@ -214,13 +218,16 @@ pcdb_instance dap_cdb_init_group(const char *a_group, int a_flags) {
//log_it(L_INFO, "Last id: %-24u" , l_cdb_i->id);
DAP_DELETE(l_arg.o);
} else {
- log_it(L_INFO, "Group \"%s\" created" , l_cdb_i->local_group);
+ log_it(L_INFO, "Group \"%s\" created", l_cdb_i->local_group);
l_cdb_i->id = 0;
}
HASH_ADD_KEYPTR(hh, s_cdb, l_cdb_i->local_group, strlen(l_cdb_i->local_group), l_cdb_i);
} else {
- log_it(L_INFO, "Group \"%s\" truncated" , l_cdb_i->local_group);
- l_cdb_i->id = 0;
+ log_it(L_INFO, "Group \"%s\" truncated", l_cdb_i->local_group);
+ DAP_DELETE(l_cdb_i->local_group);
+ cdb_destroy(l_cdb_i->cdb);
+ HASH_DEL(s_cdb, l_cdb_i);
+ DAP_DELETE(l_cdb_i);
}
FIN:
@@ -602,13 +609,6 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
if(!a_store_obj->key) {
return -2;
}
- /*if (dap_fnmatch("*.del", a_store_obj->group, 0)) {
- char *l_del_group = dap_strdup_printf("%s.del", a_store_obj->group);
- pcdb_instance l_cdb_d = dap_cdb_get_db_by_group(l_del_group);
- if (l_cdb_d) {
- l_cdb_i->id = max(l_cdb_d->id, l_cdb_i->id);
- }
- }*/
cdb_record l_rec;
l_rec.key = (char *)a_store_obj->key; //dap_strdup(a_store_obj->key);
int offset = 0;
@@ -633,12 +633,8 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
if(a_store_obj->key) {
if(cdb_del(l_cdb_i->cdb, a_store_obj->key, (int) strlen(a_store_obj->key)) == -3)
ret = 1;
- } else {
- cdb_destroy(l_cdb_i->cdb);
- if (!dap_cdb_init_group(a_store_obj->group, CDB_TRUNC | CDB_PAGEWARMUP)) {
- ret = -1;
- }
- }
+ } else if (!dap_cdb_init_group(a_store_obj->group, CDB_TRUNC | CDB_PAGEWARMUP))
+ ret = -1;
}
return ret;
}
diff --git a/modules/global-db/dap_chain_global_db_hist.c b/modules/global-db/dap_chain_global_db_hist.c
index 53897051bc..beda02d198 100644
--- a/modules/global-db/dap_chain_global_db_hist.c
+++ b/modules/global-db/dap_chain_global_db_hist.c
@@ -197,13 +197,13 @@ static void *s_list_thread_proc(void *arg)
char *l_del_group_name_replace = NULL;
char l_obj_type;
if (!dap_fnmatch("*.del", l_group_cur->name, 0)) {
- l_obj_type = 'd';
+ l_obj_type = DAP_DB$K_OPTYPE_DEL;
size_t l_del_name_len = strlen(l_group_cur->name) - 4; //strlen(".del");
l_del_group_name_replace = DAP_NEW_SIZE(char, l_del_name_len + 1);
memcpy(l_del_group_name_replace, l_group_cur->name, l_del_name_len);
l_del_group_name_replace[l_del_name_len] = '\0';
} else {
- l_obj_type = 'a';
+ l_obj_type = DAP_DB$K_OPTYPE_ADD;
}
uint64_t l_item_start = l_group_cur->last_id_synced + 1;
while (l_group_cur->count && l_dap_db_log_list->is_process) { // Number of records to be synchronized
@@ -219,15 +219,13 @@ static void *s_list_thread_proc(void *arg)
for (size_t i = 0; i < l_item_count; i++) {
dap_store_obj_t *l_obj_cur = l_objs + i;
l_obj_cur->type = l_obj_type;
- if (l_obj_type == 'd') {
+ if (l_obj_type == DAP_DB$K_OPTYPE_DEL) {
if (l_limit_time && l_obj_cur->timestamp < l_limit_time) {
- char *l_key_dup = dap_strdup(l_obj_cur->key);
dap_chain_global_db_driver_delete(l_obj_cur, 1);
- l_obj_cur->key = l_key_dup;
continue;
}
DAP_DELETE((char *)l_obj_cur->group);
- l_obj_cur->group = l_del_group_name_replace;
+ l_obj_cur->group = dap_strdup(l_del_group_name_replace);
}
dap_db_log_list_obj_t *l_list_obj = DAP_NEW_Z(dap_db_log_list_obj_t);
uint64_t l_cur_id = l_obj_cur->id;
@@ -249,6 +247,7 @@ static void *s_list_thread_proc(void *arg)
l_dap_db_log_list->list_read = l_list;
pthread_mutex_unlock(&l_dap_db_log_list->list_mutex);
}
+ DAP_DEL_Z(l_del_group_name_replace);
}
pthread_mutex_lock(&l_dap_db_log_list->list_mutex);
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 598b213aed..a40237f7fc 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -379,7 +379,11 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *
dap_chain_hash_fast_t *l_tx_prev_hash = a_tx_prev_hash;
dap_chain_datum_tx_t *l_tx_cond = dap_chain_ledger_tx_find_by_hash(l_ledger, l_tx_prev_hash);
int l_prev_cond_idx;
- dap_chain_tx_out_cond_t *l_out_cond = dap_chain_datum_tx_out_cond_get(l_tx_cond, &l_prev_cond_idx);
+ dap_chain_tx_out_cond_t *l_out_cond = dap_chain_datum_tx_out_cond_get(l_tx_cond, &l_prev_cond_idx);
+ if (!l_out_cond) {
+ log_it(L_WARNING, "Requested conditioned transaction have no conditioned output");
+ return NULL;
+ }
if (dap_chain_ledger_tx_hash_is_used_out_item(l_ledger, l_tx_prev_hash, l_prev_cond_idx)) { // TX already spent
dap_chain_datum_tx_t *l_tx_tmp;
dap_chain_hash_fast_t l_tx_cur_hash = { 0 }; // start hash
@@ -429,7 +433,7 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *
uint256_t l_old_val = l_out_cond->header.value;
SUBTRACT_256_256(l_out_cond->header.value, l_value_send, &l_out_cond->header.value);
- dap_chain_datum_tx_add_item(&l_tx, (const uint8_t *)&l_out_cond);
+ dap_chain_datum_tx_add_item(&l_tx, (const uint8_t *)l_out_cond);
l_out_cond->header.value = l_old_val;
// add 'sign' items
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 7f8af05da3..439b413307 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -412,7 +412,7 @@ void dap_chain_net_sync_gdb_broadcast(void *a_arg, const char a_op_code, const c
UNUSED(a_value);
UNUSED(a_value_len);
dap_chain_net_t *l_net = (dap_chain_net_t *)a_arg;
- if (PVT(l_net)->state >= NET_STATE_LINKS_ESTABLISHED) {
+ if (PVT(l_net)->state == NET_STATE_ONLINE) {
char *l_group;
if (a_op_code == DAP_DB$K_OPTYPE_DEL ) {
l_group = dap_strdup_printf("%s.del", a_group);
@@ -515,7 +515,7 @@ static void s_chain_callback_notify(void * a_arg, dap_chain_t *a_chain, dap_chai
if (!a_arg)
return;
dap_chain_net_t *l_net = (dap_chain_net_t *)a_arg;
- if (PVT(l_net)->state >= NET_STATE_LINKS_ESTABLISHED) {
+ if (PVT(l_net)->state == NET_STATE_ONLINE) {
pthread_rwlock_rdlock(&PVT(l_net)->rwlock);
for (dap_list_t *l_tmp = PVT(l_net)->net_links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
dap_chain_node_client_t *l_node_client = ((struct net_link *)l_tmp->data)->link;
@@ -639,7 +639,7 @@ static void s_net_state_link_replace_error(dap_worker_t *a_worker, dap_chain_nod
if (l_link_node_info)
break;
}
- if (!l_link_node_info) { // We have lost this link forever
+ if (!l_link_node_info || PVT(l_net)->state == NET_STATE_OFFLINE) { // We have lost this link forever
DAP_DELETE(l_dns_request);
return;
}
@@ -675,6 +675,10 @@ static void s_net_state_link_replace_success(dap_worker_t *a_worker, dap_chain_n
struct link_dns_request *l_dns_request = (struct link_dns_request *)a_arg;
dap_chain_net_t *l_net = l_dns_request->net;
dap_chain_net_pvt_t *l_net_pvt = PVT(l_net);
+ if (l_net_pvt->state == NET_STATE_OFFLINE) {
+ DAP_DELETE(l_dns_request);
+ return;
+ }
uint64_t l_own_addr = dap_chain_net_get_cur_addr_int(l_net);
if (a_node_info->hdr.address.uint64 == l_own_addr) {
s_net_state_link_replace_error(a_worker, a_node_info, a_arg, EWOULDBLOCK);
@@ -1518,54 +1522,31 @@ bool s_chain_net_reload_ledger_cache_once(dap_chain_net_t *l_net)
{
if (!l_net)
return false;
-
- log_it(L_WARNING,"Start one time ledger cache reloading");
-
- //
// create directory for cache checking file (cellframe-node/cache)
- //
-
char *l_cache_dir = dap_strdup_printf( "%s/%s", g_sys_dir_path, "cache");
-
- if (dap_mkdir_with_parents(l_cache_dir) != 0)
- {
+ if (dap_mkdir_with_parents(l_cache_dir) != 0) {
log_it(L_WARNING,"Error during disposable cache check file creation");
return false;
}
-
- //
// create file, if it not presented. If file exists, ledger cache operation is stopped
- //
-
char *l_cache_file = dap_strdup_printf( "%s/%s.cache", l_cache_dir, "4CFB3928-1A9A-467D-BB5E-3FDB35014E8A");
-
- if (dap_file_simple_test(l_cache_file))
- {
- log_it(L_DEBUG,"Ledger cache was already reloaded");
+ if (dap_file_simple_test(l_cache_file)) {
return false;
}
+ log_it(L_WARNING,"Start one time ledger cache reloading");
static FILE *s_cache_file = NULL;
-
s_cache_file = fopen(l_cache_file, "a");
-
- if(!s_cache_file)
- {
+ if(!s_cache_file) {
s_cache_file = fopen(l_cache_file, "w");
-
- if (!s_cache_file)
- {
+ if (!s_cache_file) {
dap_fprintf(stderr, "Can't open cache file %s for one time ledger cache reloading.\
Please, do it manually using command\
cellframe-node-cli net -net <network_name>> ledger reload'\n", l_cache_file);
return -1;
}
}
-
- //
// reload ledger cache (same as net -net <network_name>> ledger reload command)
- //
-
if (dap_file_simple_test(l_cache_file))
s_chain_net_ledger_cache_reload(l_net);
diff --git a/modules/service/stake/dap_chain_net_srv_stake.c b/modules/service/stake/dap_chain_net_srv_stake.c
index b9831fac0d..e5b5c0dbe7 100644
--- a/modules/service/stake/dap_chain_net_srv_stake.c
+++ b/modules/service/stake/dap_chain_net_srv_stake.c
@@ -156,7 +156,7 @@ static void s_stake_update(dap_chain_tx_out_cond_t *a_cond, dap_chain_datum_tx_t
else
l_stake = DAP_NEW_Z(dap_chain_net_srv_stake_item_t);
assert(l_stake);
- dap_chain_tx_out_cond_t *l_out_cond = (dap_chain_tx_out_cond_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_OUT_COND_OLD, NULL);
+ dap_chain_tx_out_cond_t *l_out_cond = (dap_chain_tx_out_cond_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_OUT_COND, NULL);
if (!l_out_cond || l_out_cond->header.subtype != DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE) {
// Stake tx is used out
HASH_DEL(s_srv_stake->itemlist, l_stake);
@@ -194,7 +194,7 @@ static bool s_stake_conditions_calc(dap_chain_tx_out_cond_t *a_cond, dap_chain_d
dap_chain_tx_out_cond_t *l_out_cond = NULL;
if (!a_cond) {
// New stake tx
- l_out_cond = (dap_chain_tx_out_cond_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_OUT_COND_OLD, NULL);
+ l_out_cond = (dap_chain_tx_out_cond_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_OUT_COND, NULL);
} else
l_out_cond = a_cond;
dap_chain_net_id_t l_cur_net_id = l_out_cond->subtype.srv_stake.hldr_addr.net_id;
--
GitLab