diff --git a/dap-sdk b/dap-sdk
index 00ddbd2a45eb69e26b36eb50920b005fee7c9461..325d5d67549c076a5a69c37987033ae55e029f95 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 00ddbd2a45eb69e26b36eb50920b005fee7c9461
+Subproject commit 325d5d67549c076a5a69c37987033ae55e029f95
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index a835fdc847b621678a30fc02eb7b9864fe8f0d02..a4f63e038b1a4d298b756c4e3b4db1b4dc0abce1 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -686,18 +686,18 @@ bool dap_chain_get_atom_last_hash(dap_chain_t *a_chain, dap_hash_fast_t *a_atom_
bool l_ret = false;
dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_cel_id, 0);
dap_chain_atom_ptr_t * l_lasts_atom;
- size_t l_lasts_atom_count=0;
- size_t* l_lasts_atom_size =NULL;
- l_lasts_atom = a_chain->callback_atom_iter_get_lasts(l_atom_iter, &l_lasts_atom_count,&l_lasts_atom_size);
- if (l_lasts_atom&& l_lasts_atom_count){
+ size_t l_lasts_atom_count = 0;
+ size_t* l_lasts_atom_size = NULL;
+ l_lasts_atom = a_chain->callback_atom_iter_get_lasts(l_atom_iter, &l_lasts_atom_count, &l_lasts_atom_size);
+ if (l_lasts_atom && l_lasts_atom_count) {
assert(l_lasts_atom_size[0]);
assert(l_lasts_atom[0]);
if(a_atom_hash){
- dap_hash_fast(l_lasts_atom[0], l_lasts_atom_size[0],a_atom_hash);
- if(dap_log_level_get() <= L_DEBUG){
- char l_hash_str[128]={[0]='\0'};
- dap_chain_hash_fast_to_str(a_atom_hash,l_hash_str,sizeof (l_hash_str)-1);
- log_it(L_DEBUG,"Send sync chain request from %s to infinity",l_hash_str);
+ dap_hash_fast(l_lasts_atom[0], l_lasts_atom_size[0], a_atom_hash);
+ if(dap_log_level_get() <= L_DEBUG) {
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(a_atom_hash, l_hash_str, sizeof(l_hash_str));
+ log_it(L_DEBUG, "Send sync chain request from %s to infinity",l_hash_str);
}
}
l_ret = true;
@@ -750,11 +750,10 @@ int dap_cert_chain_file_save(dap_chain_datum_t *datum, char *net_name)
}
const char *cert_name = cert->name;
size_t cert_path_length = dap_strlen(net_name) + dap_strlen(cert_name) + 9 + dap_strlen(s_system_chain_ca_dir);
- char *cert_path = DAP_NEW_Z_SIZE(char, cert_path_length);
+ char *cert_path = DAP_NEW_STACK_SIZE(char, cert_path_length);
snprintf(cert_path, cert_path_length, "%s/%s/%s.dcert", s_system_chain_ca_dir, net_name, cert_name);
// In cert_path resolve all `..` and `.`s
char *cert_path_c = dap_canonicalize_filename(cert_path, NULL);
- DAP_DELETE(cert_path);
// Protect the ca folder from using "/.." in cert_name
if(dap_strncmp(s_system_chain_ca_dir, cert_path_c, dap_strlen(s_system_chain_ca_dir))) {
log_it(L_ERROR, "Cert path '%s' is not in ca dir: %s", cert_path_c, s_system_chain_ca_dir);
@@ -769,6 +768,53 @@ int dap_cert_chain_file_save(dap_chain_datum_t *datum, char *net_name)
return l_ret;
}
+int dap_chain_datum_unledgered_search_iter(dap_chain_datum_t* a_datum, dap_chain_t* a_chain)
+{
+ /* Only for datum types which do not appear in ledger */
+ switch (a_datum->header.type_id) {
+ case DAP_CHAIN_DATUM_TOKEN_DECL:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION:
+ case DAP_CHAIN_DATUM_TX:
+ return 0;
+ /* The types above are checked while adding to ledger, otherwise let's unfold the chains */
+ default: {
+ if (!a_chain->callback_atom_get_datums) {
+ log_it(L_WARNING, "No callback set to fetch datums from atom in chain '%s'", a_chain->name);
+ return -2;
+ }
+ int l_found = 0;
+ dap_chain_hash_fast_t l_datum_hash;
+ dap_hash_fast(a_datum, dap_chain_datum_size(a_datum), &l_datum_hash);
+ dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_chain->cells->id, 0);
+ size_t l_atom_size = 0;
+ for (dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
+ l_atom && l_atom_size && !l_found;
+ l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size))
+ {
+ size_t l_datums_count = 0;
+ dap_chain_datum_t **l_datums = a_chain->callback_atom_get_datums(l_atom, l_atom_size, &l_datums_count);
+ for (size_t i = 0; i < l_datums_count; ++i) {
+ if ((*(l_datums + i))->header.type_id != a_datum->header.type_id) {
+ break;
+ }
+ dap_chain_hash_fast_t l_datum_i_hash;
+ dap_hash_fast(*(l_datums + i), dap_chain_datum_size(*(l_datums + i)), &l_datum_i_hash);
+ if (!memcmp(&l_datum_i_hash, &l_datum_hash, DAP_CHAIN_HASH_FAST_SIZE)) {
+ char l_datum_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_hash_fast_to_str(&l_datum_hash, l_datum_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
+ log_it(L_INFO, "Datum %s found in chain %lu", l_datum_hash_str, a_chain->id.uint64);
+ l_found = 1;
+ break;
+ }
+ }
+ DAP_DEL_Z(l_datums);
+ }
+ a_chain->callback_atom_iter_delete(l_atom_iter);
+ return l_found;
+ } /* default */
+ }
+}
+
const char* dap_chain_get_path(dap_chain_t *a_chain){
return DAP_CHAIN_PVT(a_chain)->file_storage_dir;
}
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 02e5f7198a9d01a4f84ebdb4440b49e8f0ba7c0d..29b2df85cbffaee81c84febca1ad6835a4d2de5f 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -595,18 +595,14 @@ dap_chain_datum_token_t *dap_chain_ledger_token_ticker_check(dap_ledger_t * a_le
static void s_tx_header_print(dap_string_t *a_str_out, dap_chain_datum_tx_t *a_tx,
const char *a_hash_out_type, dap_chain_hash_fast_t *a_tx_hash)
{
- // transaction time
char l_time_str[32] = "unknown";
if (a_tx->header.ts_created) {
uint64_t l_ts = a_tx->header.ts_created;
dap_ctime_r(&l_ts, l_time_str);
}
- char *l_tx_hash_str;
- if (!dap_strcmp(a_hash_out_type, "hex")) {
- l_tx_hash_str = dap_chain_hash_fast_to_str_new(a_tx_hash);
- } else {
- l_tx_hash_str = dap_enc_base58_encode_hash_to_str(a_tx_hash);
- }
+ char *l_tx_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(a_tx_hash)
+ : dap_chain_hash_fast_to_str_new(a_tx_hash);
dap_string_append_printf(a_str_out, "TX hash %s \n\t%s",l_tx_hash_str, l_time_str);
DAP_DELETE(l_tx_hash_str);
}
@@ -1788,11 +1784,11 @@ static void s_threshold_txs_free(dap_ledger_t *a_ledger){
HASH_ITER(hh, l_pvt->threshold_txs, l_current, l_tmp) {
if (l_current->ts_added < l_time_cut_off) {
HASH_DEL(l_pvt->threshold_txs, l_current);
- char *l_hash_tx = dap_chain_hash_fast_to_str_new(&l_current->tx_hash_fast);
+ char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_current->tx_hash_fast, l_tx_hash_str, sizeof(l_tx_hash_str));
DAP_DELETE(l_current->tx);
DAP_DELETE(l_current);
- log_it(L_NOTICE, "Removed transaction %s form threshold ledger", l_hash_tx);
- DAP_DELETE(l_hash_tx);
+ log_it(L_NOTICE, "Removed transaction %s form threshold ledger", l_tx_hash_str);
}
}
pthread_rwlock_unlock(&l_pvt->threshold_txs_rwlock);
@@ -1810,11 +1806,11 @@ static void s_threshold_emission_free(dap_ledger_t *a_ledger){
pthread_rwlock_wrlock(&l_pvt->threshold_emissions_rwlock);
HASH_ITER(hh, l_pvt->threshold_emissions, l_current, l_tmp) {
if (l_current->ts_added < l_time_cut_off) {
- char *l_hash_token = dap_chain_hash_fast_to_str_new(&l_current->datum_token_emission_hash);
+ char l_token_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_current->datum_token_emission_hash, l_token_hash_str, sizeof(l_token_hash_str));
HASH_DEL(l_pvt->threshold_emissions, l_current);
DAP_DELETE(l_current->datum_token_emission);
- log_it(L_NOTICE, "Removed token emission %s form threshold ledger", l_hash_token);
- DAP_DELETE(l_hash_token);
+ log_it(L_NOTICE, "Removed token emission %s form threshold ledger", l_token_hash_str);
}
}
pthread_rwlock_unlock(&l_pvt->threshold_emissions_rwlock);
@@ -2141,10 +2137,9 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
}
// check if such emission is already present in table
- dap_chain_hash_fast_t l_token_emission_hash={0};
+ dap_chain_hash_fast_t l_token_emission_hash = { };
//dap_chain_hash_fast_t * l_token_emission_hash_ptr = &l_token_emission_hash;
dap_hash_fast(a_token_emission, a_token_emission_size, &l_token_emission_hash);
- char * l_hash_str = dap_chain_hash_fast_to_str_new(&l_token_emission_hash);
pthread_rwlock_rdlock(l_token_item ? &l_token_item->token_emissions_rwlock
: &l_ledger_pvt->threshold_emissions_rwlock);
HASH_FIND(hh,l_token_item ? l_token_item->token_emissions : l_ledger_pvt->threshold_emissions,
@@ -2154,15 +2149,17 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
: &l_ledger_pvt->threshold_emissions_rwlock);
if(l_token_emission_item ) {
if(s_debug_more) {
+ char l_token_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_token_emission_hash, l_token_hash_str, sizeof(l_token_hash_str));
if ( l_token_emission_item->datum_token_emission->hdr.version == 2 ) {
char *l_balance = dap_chain_balance_print(l_token_emission_item->datum_token_emission->hdr.value_256);
log_it(L_ERROR, "Can't add token emission datum of %s %s ( %s ): already present in cache",
- l_balance, l_token_ticker, l_hash_str);
+ l_balance, l_token_ticker, l_token_hash_str);
DAP_DELETE(l_balance);
}
else
log_it(L_ERROR, "Can't add token emission datum of %"DAP_UINT64_FORMAT_U" %s ( %s ): already present in cache",
- l_token_emission_item->datum_token_emission->hdr.value, l_token_ticker, l_hash_str);
+ l_token_emission_item->datum_token_emission->hdr.value, l_token_ticker, l_token_hash_str);
}
l_ret = -1;
}else if ( (! l_token_item) && ( l_threshold_emissions_count >= s_threshold_emissions_max)) {
@@ -2171,7 +2168,6 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
s_threshold_emissions_max);
l_ret = -2;
}
- DAP_DELETE(l_hash_str);
if (l_ret || !PVT(a_ledger)->check_token_emission)
return l_ret;
// Check emission correctness
@@ -2316,7 +2312,8 @@ static void s_ledger_emission_cache_update(dap_ledger_t *a_ledger, dap_chain_led
uint8_t *l_cache = DAP_NEW_STACK_SIZE(uint8_t, l_cache_size);
memcpy(l_cache, &a_emission_item->tx_used_out, sizeof(dap_hash_fast_t));
memcpy(l_cache + sizeof(dap_hash_fast_t), a_emission_item->datum_token_emission, a_emission_item->datum_token_emission_size);
- char *l_hash_str = dap_hash_fast_to_str_new(&a_emission_item->datum_token_emission_hash);
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&a_emission_item->datum_token_emission_hash, l_hash_str, sizeof(l_hash_str));
if (dap_global_db_set(l_gdb_group, l_hash_str, l_cache, l_cache_size, false, NULL, NULL)) {
log_it(L_WARNING, "Ledger cache mismatch");
}
@@ -2404,7 +2401,6 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
a_emission_hash, sizeof(*a_emission_hash), l_token_emission_item);
if(a_safe_call) pthread_rwlock_unlock(l_token_item ? &l_token_item->token_emissions_rwlock
: &l_ledger_pvt->threshold_emissions_rwlock);
- char *l_hash_str = dap_chain_hash_fast_to_str_new(a_emission_hash);
if (!l_token_emission_item) {
l_token_emission_item = DAP_NEW_Z(dap_chain_ledger_token_emission_item_t);
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
@@ -2419,7 +2415,6 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
if (!s_chain_ledger_token_tsd_check(l_token_item, (dap_chain_datum_token_emission_t *)a_token_emission)) {
DAP_DELETE(l_token_emission_item->datum_token_emission);
DAP_DELETE(l_token_emission_item);
- DAP_DELETE(l_hash_str);
return -114;
}
}
@@ -2440,7 +2435,6 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
DAP_DELETE(l_value);
DAP_DELETE(l_token_emission_item->datum_token_emission);
DAP_DELETE(l_token_emission_item);
- DAP_DELETE(l_hash_str);
return -4;
}
if (PVT(a_ledger)->cached)
@@ -2495,6 +2489,8 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
} else {
if (l_token_item) {
if(s_debug_more) {
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(a_emission_hash, l_hash_str, sizeof(l_hash_str));
if ( ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.version == 2 ) {
char *l_balance = dap_chain_balance_print(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value_256);
log_it(L_ERROR, "Duplicate token emission datum of %s %s ( %s )", l_balance, c_token_ticker, l_hash_str);
@@ -2507,17 +2503,16 @@ static inline int s_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_e
}
l_ret = -1;
}
- DAP_DELETE(l_hash_str);
return l_ret;
}
void s_ledger_stake_lock_cache_update(dap_ledger_t *a_ledger, dap_chain_ledger_stake_lock_item_t *a_stake_lock_item)
{
- char *l_hash_str = dap_chain_hash_fast_to_str_new(&a_stake_lock_item->tx_for_stake_lock_hash);
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&a_stake_lock_item->tx_for_stake_lock_hash, l_hash_str, sizeof(l_hash_str));
char *l_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_STAKE_LOCK_STR);
if (dap_global_db_set(l_group, l_hash_str, &a_stake_lock_item->tx_used_out, sizeof(dap_hash_fast_t), false, NULL, NULL))
log_it(L_WARNING, "Ledger cache mismatch");
- DAP_DEL_Z(l_hash_str);
DAP_DEL_Z(l_group);
}
@@ -3952,9 +3947,9 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
int res = dap_chain_ledger_tx_remove(a_ledger, &l_tx_prev_hash_to_del, a_tx->header.ts_created);
if(res == -2) {
if(s_debug_more) {
- char * l_tx_prev_hash_str = dap_chain_hash_fast_to_str_new(&l_tx_prev_hash_to_del);
+ char l_tx_prev_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_tx_prev_hash_to_del, l_tx_prev_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
log_it(L_ERROR, "Can't delete previous transactions because hash=%s not found", l_tx_prev_hash_str);
- DAP_DELETE(l_tx_prev_hash_str);
}
ret = -100;
l_outs_used = i;
@@ -3962,9 +3957,9 @@ static inline int s_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, d
}
else if(res != 1) {
if(s_debug_more) {
- char * l_tx_prev_hash_str = dap_chain_hash_fast_to_str_new(&l_tx_prev_hash_to_del);
+ char l_tx_prev_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_tx_prev_hash_to_del, l_tx_prev_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
log_it(L_ERROR, "Can't delete previous transactions with hash=%s", l_tx_prev_hash_str);
- DAP_DELETE(l_tx_prev_hash_str);
}
ret = -101;
l_outs_used = i;
@@ -4189,9 +4184,9 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
if (PVT(a_ledger)->cached) {
// Remove it from cache
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_tx_hash);
+ char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(a_tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
dap_global_db_del(l_gdb_group, l_tx_hash_str, NULL, NULL);
- DAP_DELETE(l_tx_hash_str);
DAP_DELETE(l_gdb_group);
}
l_ret = 1;
@@ -4210,10 +4205,10 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
if (PVT(a_ledger)->cached) {
// Add it to cache
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_SPENT_TXS_STR);
- char *l_tx_hash_str = dap_hash_fast_to_str_new(a_tx_hash);
+ char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(a_tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
if (dap_global_db_set(l_gdb_group, l_tx_hash_str, &l_item_used->cache_data, sizeof(l_item_used->cache_data), false, NULL, NULL))
debug_if(s_debug_more, L_WARNING, "Ledger cache mismatch");
- DAP_DELETE(l_tx_hash_str);
DAP_DELETE(l_gdb_group);
}
}
@@ -4794,7 +4789,7 @@ uint256_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, d
dap_chain_datum_tx_t *l_tx_tmp;
dap_chain_hash_fast_t l_tx_first_hash = { 0 }; // start hash
/* size_t l_pub_key_size = a_key_from->pub_key_data_size;
- uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_key_from, &l_pub_key_size);*/
+ uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(a_key_from, &l_pub_key_size);*/
dap_chain_tx_out_cond_t *l_tx_out_cond;
// Find all transactions
do {
diff --git a/modules/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index 4762d843621b0144ea08ae96470f56031ceffbee..1e537d2fc1b89d535299c52aef829e58a387c5c1 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -58,12 +58,16 @@ typedef struct dap_chain_atom_iter{
typedef enum dap_chain_atom_verify_res{
- ATOM_ACCEPT=0,
- ATOM_PASS=1,
- ATOM_REJECT=2,
- ATOM_MOVE_TO_THRESHOLD=3
+ ATOM_ACCEPT = 0, ATOM_PASS, ATOM_REJECT, ATOM_MOVE_TO_THRESHOLD
} dap_chain_atom_verify_res_t;
+static const char* const dap_chain_atom_verify_res_str[] = {
+ [ATOM_ACCEPT] = "accepted",
+ [ATOM_PASS] = "skipped",
+ [ATOM_REJECT] = "rejected",
+ [ATOM_MOVE_TO_THRESHOLD] = "thresholded"
+};
+
typedef dap_chain_t* (*dap_chain_callback_new_t)(void);
typedef void (*dap_chain_callback_t)(dap_chain_t *);
@@ -240,5 +244,5 @@ bool dap_chain_get_atom_last_hash(dap_chain_t *a_chain, dap_hash_fast_t *a_atom_
ssize_t dap_chain_atom_save(dap_chain_t *a_chain, const uint8_t *a_atom, size_t a_atom_size, dap_chain_cell_id_t a_cell_id);
void dap_chain_add_mempool_notify_callback(dap_chain_t *a_chain, dap_store_obj_callback_notify_t a_callback, void *a_cb_arg);
int dap_cert_chain_file_save(dap_chain_datum_t *datum, char *net_name);
-
+int dap_chain_datum_unledgered_search_iter(dap_chain_datum_t* a_datum, dap_chain_t* a_chain);
const char* dap_chain_get_path(dap_chain_t *a_chain);
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 0d3229773f508e2e0ef155fb06d05d00832d4ca3..1570593b5ef74df075a6c774b61f269036c4c4d6 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
@@ -533,13 +533,9 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
}
// Store receipt if any problems with transactions
- dap_chain_hash_fast_t l_receipt_hash={0};
- dap_hash_fast(l_receipt,l_receipt_size,&l_receipt_hash);
-
- char *l_receipt_hash_str = dap_chain_hash_fast_to_str_new(&l_receipt_hash);
+ char *l_receipt_hash_str;
+ dap_get_data_hash_str_static(l_receipt, l_receipt_size, l_receipt_hash_str);
dap_global_db_set("local.receipts", l_receipt_hash_str, l_receipt, l_receipt_size, false, NULL, NULL);
- DAP_DELETE(l_receipt_hash_str);
-
size_t l_success_size;
if (!l_usage->is_grace) {
// Form input transaction
@@ -559,7 +555,6 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch , void* a_arg)
}
dap_stream_ch_chain_net_srv_pkt_success_t *l_success = DAP_NEW_STACK_SIZE(dap_stream_ch_chain_net_srv_pkt_success_t,
l_success_size);
-
memset(&l_success->hdr, 0, sizeof(l_success->hdr));
l_success->hdr.usage_id = l_usage->id;
diff --git a/modules/channel/chain/dap_stream_ch_chain.c b/modules/channel/chain/dap_stream_ch_chain.c
index 18f97da5ca36e5a12c66b610e66c4da9b6595625..567eaaf33f10e8331311834946a58f0d6f0ed47d 100644
--- a/modules/channel/chain/dap_stream_ch_chain.c
+++ b/modules/channel/chain/dap_stream_ch_chain.c
@@ -1877,9 +1877,9 @@ void s_stream_ch_packet_out(dap_stream_ch_t *a_ch, void *a_arg)
l_hash_item = DAP_NEW_Z(dap_stream_ch_chain_hash_item_t);
l_hash_item->hash = *l_ch_chain->request_atom_iter->cur_hash;
if(s_debug_more){
- char *l_atom_hash_str= dap_chain_hash_fast_to_str_new(&l_hash_item->hash);
+ char l_atom_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_hash_item->hash, l_atom_hash_str, sizeof(l_atom_hash_str));
log_it(L_INFO, "Out CHAIN pkt: atom hash %s (size %zd) ", l_atom_hash_str, l_ch_chain->request_atom_iter->cur_size);
- DAP_DELETE(l_atom_hash_str);
}
s_stream_ch_chain_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_CHAIN, l_ch_chain->request_hdr.net_id.uint64,
l_ch_chain->request_hdr.chain_id.uint64, l_ch_chain->request_hdr.cell_id.uint64,
diff --git a/modules/common/dap_chain_common.c b/modules/common/dap_chain_common.c
index d6d9844b91b5ff61517aaef5bfd1ba34b0ee39fc..e1ccc2930913f3994f02a57dd3d5d1aa1e182ae5 100644
--- a/modules/common/dap_chain_common.c
+++ b/modules/common/dap_chain_common.c
@@ -191,7 +191,7 @@ int dap_chain_addr_fill_from_key(dap_chain_addr_t *a_addr, dap_enc_key_t *a_key,
{
dap_sign_type_t l_type = dap_sign_type_from_key_type(a_key->type);
size_t l_pub_key_data_size;
- uint8_t *l_pub_key_data = dap_enc_key_serealize_pub_key(a_key, &l_pub_key_data_size);
+ uint8_t *l_pub_key_data = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_data_size);
if (!l_pub_key_data) {
log_it(L_ERROR,"Can't fill address from key, its empty");
return -1;
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index e717aead2901d827d0420bc37f97a47c46bf1b80..5cb3bc3ecc574425062b59f4803c0417a311d5ae 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -117,11 +117,9 @@ void s_datum_token_dump_tsd(dap_string_t *a_str_out, dap_chain_datum_token_t *a_
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_ADD :
if(l_tsd->size == sizeof(dap_chain_hash_fast_t) ){
- char *l_hash_str;
- if(!dap_strcmp(a_hash_out_type, "hex") || !dap_strcmp(a_hash_out_type, "content_hash") )
- l_hash_str = dap_chain_hash_fast_to_str_new((dap_chain_hash_fast_t*) l_tsd->data);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str((dap_chain_hash_fast_t*) l_tsd->data);
+ char *l_hash_str = (!dap_strcmp(a_hash_out_type, "hex") || !dap_strcmp(a_hash_out_type, "content_hash"))
+ ? dap_chain_hash_fast_to_str_new((dap_chain_hash_fast_t*) l_tsd->data)
+ : dap_enc_base58_encode_hash_to_str((dap_chain_hash_fast_t*) l_tsd->data);
dap_string_append_printf(a_str_out,"total_signs_add: %s\n", l_hash_str);
DAP_DELETE( l_hash_str );
}else
@@ -129,11 +127,9 @@ void s_datum_token_dump_tsd(dap_string_t *a_str_out, dap_chain_datum_token_t *a_
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_REMOVE :
if(l_tsd->size == sizeof(dap_chain_hash_fast_t) ){
- char *l_hash_str;
- if(!dap_strcmp(a_hash_out_type,"hex")|| !dap_strcmp(a_hash_out_type, "content_hash"))
- l_hash_str = dap_chain_hash_fast_to_str_new((dap_chain_hash_fast_t*) l_tsd->data);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str((dap_chain_hash_fast_t*) l_tsd->data);
+ char *l_hash_str = (!dap_strcmp(a_hash_out_type,"hex")|| !dap_strcmp(a_hash_out_type, "content_hash"))
+ ? dap_chain_hash_fast_to_str_new((dap_chain_hash_fast_t*) l_tsd->data)
+ : dap_enc_base58_encode_hash_to_str((dap_chain_hash_fast_t*) l_tsd->data);
dap_string_append_printf(a_str_out,"total_signs_remove: %s\n", l_hash_str );
DAP_DELETE( l_hash_str );
}else
@@ -223,11 +219,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
if (l_in_item && dap_hash_fast_is_blank(&l_in_item->header.tx_prev_hash))
l_is_first = true;
char l_tmp_buf[70];
- char *l_hash_str = NULL;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(a_tx_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(a_tx_hash);
+ char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(a_tx_hash)
+ : dap_chain_hash_fast_to_str_new(a_tx_hash);
dap_string_append_printf(a_str_out, "transaction:%s hash %s\n TS Created: %s%s%s\n Items:\n",
l_is_first ? " (emit)" : "", l_hash_str, dap_ctime_r(&l_ts_create, l_tmp_buf),
a_ticker ? " Token ticker: " : "", a_ticker ? a_ticker : "");
@@ -235,7 +229,6 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
uint32_t l_tx_items_count = 0;
uint32_t l_tx_items_size = a_datum->header.tx_items_size;
dap_sign_t *l_sign_tmp;
- dap_chain_hash_fast_t l_pkey_hash_tmp;
dap_hash_fast_t *l_hash_tmp = NULL;
dap_pkey_t *l_pkey_tmp;
while (l_tx_items_count < l_tx_items_size) {
@@ -247,10 +240,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
if (dap_hash_fast_is_blank(l_hash_tmp)) {
l_hash_str = dap_strdup("BLANK");
} else {
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(l_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(l_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(l_hash_tmp);
}
dap_string_append_printf(a_str_out, "\t IN:\nTx_prev_hash: %s\n"
"\t\t Tx_out_prev_idx: %u\n",
@@ -287,10 +279,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
} break;
case TX_ITEM_TYPE_IN_EMS: {
l_hash_tmp = &((dap_chain_tx_in_ems_t*)item)->header.token_emission_hash;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(l_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(l_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN_EMS:\n"
"\t\t ticker: %s \n"
"\t\t token_emission_hash: %s\n"
@@ -302,10 +293,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
} break;
case TX_ITEM_TYPE_IN_EMS_EXT: {
l_hash_tmp = &((dap_chain_tx_in_ems_ext_t*)item)->header.ext_tx_hash;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(l_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(l_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN_EMS EXT:\n"
"\t\t Version: %u\n"
"\t\t Ticker: %s\n"
@@ -369,11 +359,11 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
} break;
case TX_ITEM_TYPE_PKEY: {
l_pkey_tmp = (dap_pkey_t*)((dap_chain_tx_pkey_t*)item)->pkey;
+ dap_chain_hash_fast_t l_pkey_hash_tmp;
dap_hash_fast(l_pkey_tmp->pkey, l_pkey_tmp->header.size, &l_pkey_hash_tmp);
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_pkey_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_pkey_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_pkey_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(&l_pkey_hash_tmp);
dap_string_append_printf(a_str_out, "\t PKey: \n"
"\t\t SIG type: %s\n"
"\t\t SIG size: %u\n"
@@ -399,10 +389,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
} break;
case TX_ITEM_TYPE_IN_COND:
l_hash_tmp = &((dap_chain_tx_in_cond_t*)item)->header.tx_prev_hash;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(l_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(l_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN COND:\n\t\tReceipt_idx: %u\n"
"\t\t Tx_prev_hash: %s\n"
"\t\t Tx_out_prev_idx: %u\n",
@@ -432,10 +421,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
char *l_value_str = dap_chain_balance_print(((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi);
char *l_coins_str = dap_chain_balance_to_coins(((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi);
l_hash_tmp = &((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(l_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(l_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t\t\t unit: 0x%08x\n"
"\t\t\t pkey: %s\n"
"\t\t\t max price: %s (%s)\n",
@@ -452,10 +440,9 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
dap_chain_addr_t *l_signing_addr = &((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake_pos_delegate.signing_addr;
char *l_addr_str = dap_chain_addr_to_str(l_signing_addr);
l_hash_tmp = &l_signing_addr->data.hash_fast;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(l_hash_tmp);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(l_hash_tmp);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
+ : dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t\t\t signing_addr: %s\n"
"\t\t\t with pkey hash %s\n"
"\t\t\t signer_node_addr: "NODE_ADDR_FP_STR"\n",
@@ -535,11 +522,9 @@ void dap_chain_datum_dump(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, c
}
dap_hash_fast_t l_datum_hash;
dap_hash_fast(a_datum->data, a_datum->header.data_size, &l_datum_hash);
- char *l_hash_str = NULL;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_datum_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_datum_hash);
+ char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_datum_hash)
+ : dap_chain_hash_fast_to_str_new(&l_datum_hash);
switch (a_datum->header.type_id) {
case DAP_CHAIN_DATUM_TOKEN_DECL: {
size_t l_token_size = a_datum->header.data_size;
@@ -732,17 +717,12 @@ void dap_chain_datum_dump(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, c
dap_string_append_printf(a_str_out,"=== Datum anchor ===\n");
dap_string_append_printf(a_str_out, "hash: %s\n", l_hash_str);
dap_string_append_printf(a_str_out, "size: %zd\n", l_anchor_size);
- char *l_decree_hash_str = NULL;
- dap_hash_fast_t l_decree_hash ={0};
+ dap_hash_fast_t l_decree_hash = { };
dap_chain_datum_anchor_get_hash_from_data(l_anchor, &l_decree_hash);
//dap_chain_hash_fast_to_str(&l_decree_hash, l_decree_hash_str, 40);
-
- l_decree_hash_str = dap_chain_hash_fast_to_str_new(&l_decree_hash);
-
+ char l_decree_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_decree_hash, l_decree_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
dap_string_append_printf(a_str_out, "decree hash: %s\n", l_decree_hash_str);
-
- DAP_DELETE(l_decree_hash_str);
-
dap_chain_datum_anchor_certs_dump(a_str_out, l_anchor->data_n_sign + l_anchor->header.data_size, l_anchor->header.signs_size, a_hash_out_type);
} break;
}
@@ -751,11 +731,9 @@ void dap_chain_datum_dump(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, c
json_object * dap_chain_datum_to_json(dap_chain_datum_t* a_datum){
json_object *l_object = json_object_new_object();
- dap_hash_fast_t l_hash_data = {0};
- dap_hash_fast(a_datum->data, a_datum->header.data_size, &l_hash_data);
- char *l_hash_data_str = dap_hash_fast_to_str_new(&l_hash_data);
+ char *l_hash_data_str;
+ dap_get_data_hash_str_static(a_datum->data, a_datum->header.data_size, l_hash_data_str);
json_object *l_obj_data_hash = json_object_new_string(l_hash_data_str);
- DAP_DELETE(l_hash_data_str);
json_object *l_obj_version = json_object_new_int(a_datum->header.version_id);
json_object *l_obj_size = json_object_new_int(a_datum->header.data_size);
json_object *l_obj_ts_created = json_object_new_uint64(a_datum->header.ts_create);
diff --git a/modules/common/dap_chain_datum_anchor.c b/modules/common/dap_chain_datum_anchor.c
index 3be303ad469f5a57fba1cc57142b9fdc7f27bc13..736781fc7d6a822c135e557fd6cc542dcd76dc8e 100644
--- a/modules/common/dap_chain_datum_anchor.c
+++ b/modules/common/dap_chain_datum_anchor.c
@@ -71,7 +71,7 @@ void dap_chain_datum_anchor_certs_dump(dap_string_t * a_str_out, byte_t * a_sign
size_t l_offset = 0;
for (int i = 1; l_offset < (a_certs_size); i++) {
- dap_sign_t *l_sign = (dap_sign_t *) (a_signs + l_offset);
+ dap_sign_t *l_sign = (dap_sign_t*)(a_signs + l_offset);
l_offset += dap_sign_get_size(l_sign);
if (l_sign->header.sign_size == 0) {
dap_string_append_printf(a_str_out, "<CORRUPTED - 0 size signature>\n");
@@ -83,13 +83,9 @@ void dap_chain_datum_anchor_certs_dump(dap_string_t * a_str_out, byte_t * a_sign
dap_string_append_printf(a_str_out, "<CORRUPTED - can't calc hash>\n");
continue;
}
-
- char *l_hash_str = NULL;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_pkey_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_pkey_hash);
-
+ char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_pkey_hash)
+ : dap_chain_hash_fast_to_str_new(&l_pkey_hash);
dap_string_append_printf(a_str_out, "%d) %s, %s, %u bytes\n", i, l_hash_str,
dap_sign_type_to_str(l_sign->header.type), l_sign->header.sign_size);
DAP_DEL_Z(l_hash_str);
diff --git a/modules/common/dap_chain_datum_decree.c b/modules/common/dap_chain_datum_decree.c
index 9826bcbf9264ccf4edef107679eb5c30e66a2272..40adfe8121c6761740e0cf694624396766441399 100644
--- a/modules/common/dap_chain_datum_decree.c
+++ b/modules/common/dap_chain_datum_decree.c
@@ -392,9 +392,9 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
memcpy(l_owner_pkey, l_tsd->data, l_tsd->size);
dap_hash_fast_t l_owner_pkey_hash = {0};
dap_hash_fast(l_owner_pkey->pkey, l_owner_pkey->header.size, &l_owner_pkey_hash);
- char *l_owner_pkey_str = dap_chain_hash_fast_to_str_new(&l_owner_pkey_hash);
+ char l_owner_pkey_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_owner_pkey_hash, l_owner_pkey_str, sizeof(l_owner_pkey_str));
dap_string_append_printf(a_str_out, "\tOwner fingerprint: %s\n", l_owner_pkey_str);
- DAP_DELETE(l_owner_pkey_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
if (l_tsd->size > sizeof(uint256_t)){
@@ -424,12 +424,9 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
}
dap_hash_fast_t l_stake_tx = {0};
l_stake_tx = dap_tsd_get_scalar(l_tsd, dap_hash_fast_t);
- char *l_stake_tx_hash = "";
- if (strcmp(a_hash_out_type, "hex") == 0) {
- l_stake_tx_hash = dap_hash_fast_to_str_new(&l_stake_tx);
- } else {
- l_stake_tx_hash = dap_enc_base58_encode_hash_to_str(&l_stake_tx);
- }
+ char *l_stake_tx_hash = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_stake_tx)
+ : dap_chain_hash_fast_to_str_new(&l_stake_tx);
dap_string_append_printf(a_str_out, "\tStake tx: %s\n", l_stake_tx_hash);
DAP_DELETE(l_stake_tx_hash);
break;
@@ -454,12 +451,9 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
dap_string_append_printf(a_str_out, "\tSigning addr: %s\n", l_stake_addr_signing_str);
dap_chain_hash_fast_t *l_pkey_signing = DAP_NEW(dap_chain_hash_fast_t);
memcpy(l_pkey_signing, l_stake_addr_signing.data.key, sizeof(dap_chain_hash_fast_t));
- char *l_pkey_signing_str = NULL;
- if (strcmp(a_hash_out_type, "hex") == 0) {
- l_pkey_signing_str = dap_hash_fast_to_str_new(l_pkey_signing);
- } else {
- l_pkey_signing_str = dap_enc_base58_encode_hash_to_str(l_pkey_signing);
- }
+ char *l_pkey_signing_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(l_pkey_signing)
+ : dap_chain_hash_fast_to_str_new(l_pkey_signing);
dap_string_append_printf(a_str_out, "\tSigning pkey fingerprint: %s\n", l_pkey_signing_str);
DAP_DELETE(l_stake_addr_signing_str);
DAP_DELETE(l_pkey_signing_str);
@@ -528,12 +522,9 @@ void dap_chain_datum_decree_certs_dump(dap_string_t * a_str_out, byte_t * a_sign
continue;
}
- char *l_hash_str = NULL;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_pkey_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_pkey_hash);
-
+ char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_pkey_hash)
+ : dap_chain_hash_fast_to_str_new(&l_pkey_hash);
dap_string_append_printf(a_str_out, "%d) %s, %s, %u bytes\n", i, l_hash_str,
dap_sign_type_to_str(l_sign->header.type), l_sign->header.sign_size);
DAP_DEL_Z(l_hash_str);
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 3d11dfe3eb242d4d596c963b2d73fba75e9172d5..f9f9ec7ec6cd07eedf38763019929e55623d8c87 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -233,11 +233,9 @@ void dap_chain_datum_token_certs_dump(dap_string_t * a_str_out, byte_t * a_data_
continue;
}
- char *l_hash_str = NULL;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_pkey_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_pkey_hash);
+ char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_pkey_hash)
+ : dap_chain_hash_fast_to_str_new(&l_pkey_hash);
dap_string_append_printf(a_str_out, "%d) %s, %s, %u bytes\n", i, l_hash_str,
dap_sign_type_to_str(l_sign->header.type), l_sign->header.sign_size);
@@ -426,7 +424,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_add_sign(dap_enc_key_
{
size_t l_pub_key_size = 0;
dap_sign_t *l_sign = (dap_sign_t *)(a_emission->tsd_n_signs + a_emission->data.type_auth.tsd_total_size);
- uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_sign_key, &l_pub_key_size);
+ uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(a_sign_key, &l_pub_key_size);
for (int i = 0; i < a_emission->data.type_auth.signs_count; i++) {
if (l_sign->header.sign_pkey_size == l_pub_key_size &&
!memcmp(l_sign->pkey_n_sign, l_pub_key, l_pub_key_size))
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index bce0144e53b7e3a491c19969ce6d4cfc14d38b9d..6d9b329728e48d4be6172eb36ef0bdd298be892a 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -316,10 +316,7 @@ json_object *dap_chain_datum_tx_to_json(dap_chain_datum_tx_t *a_tx){
break;
}
dap_chain_tx_item_type_t l_item_type = dap_chain_datum_tx_item_get_type(item);
- json_object *l_obj_item_type = NULL;
- json_object *l_obj_item_data = NULL;
- dap_hash_fast_t a_tx_hash = {0};
- char *l_hash_str = NULL;
+ json_object *l_obj_item_type = NULL, *l_obj_item_data = NULL;
switch (l_item_type) {
case TX_ITEM_TYPE_IN:
l_obj_item_type = json_object_new_string("TX_ITEM_TYPE_IN");
@@ -379,12 +376,12 @@ json_object *dap_chain_datum_tx_to_json(dap_chain_datum_tx_t *a_tx){
l_obj_item_type = json_object_new_string("TX_ITEM_TYPE_TSD");
l_obj_item_data = dap_chain_datum_tx_item_tsd_to_json((dap_chain_tx_tsd_t*)item);
break;
- default:
- dap_hash_fast(a_tx, dap_chain_datum_tx_get_size(a_tx), &a_tx_hash);
- l_hash_str = dap_chain_hash_fast_to_str_new(&a_tx_hash);
+ default: {
+ char *l_hash_str;
+ dap_get_data_hash_str_static(a_tx, dap_chain_datum_tx_get_size(a_tx), l_hash_str);
log_it(L_NOTICE, "Transaction %s has an item whose type cannot be handled by the dap_chain_datum_tx_to_json function.", l_hash_str);
- DAP_DELETE(l_hash_str);
break;
+ }
}
if (!l_obj_item_type){
json_object_array_add(l_obj_items, json_object_new_null());
diff --git a/modules/common/dap_chain_datum_tx_items.c b/modules/common/dap_chain_datum_tx_items.c
index d6479b0948836a55d6a81fc326687acc2719fc73..7b64c29b965fc0f0d7ba5085fa87072cb90a925b 100644
--- a/modules/common/dap_chain_datum_tx_items.c
+++ b/modules/common/dap_chain_datum_tx_items.c
@@ -247,9 +247,9 @@ json_object *dap_chain_datum_tx_item_in_ems_to_json(const dap_chain_tx_in_ems_t
json_object *l_object = json_object_new_object();
json_object *l_obj_ticker = json_object_new_string(a_in_ems->header.ticker);
json_object *l_obj_chain_id = json_object_new_uint64(a_in_ems->header.token_emission_chain_id.uint64);
- char *l_ehf = dap_chain_hash_fast_to_str_new(&a_in_ems->header.token_emission_hash);
+ char l_ehf[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&a_in_ems->header.token_emission_hash, l_ehf, sizeof(l_ehf));
json_object *l_obj_ehf = json_object_new_string(l_ehf);
- DAP_DELETE(l_ehf);
json_object_object_add(l_object, "ticker", l_obj_ticker);
json_object_object_add(l_object, "chainId", l_obj_chain_id);
json_object_object_add(l_object, "emissionHash", l_obj_ehf);
@@ -293,9 +293,9 @@ dap_chain_tx_tsd_t *dap_chain_datum_tx_item_tsd_create(void *a_data, int a_type,
json_object* dap_chain_datum_tx_item_in_to_json(dap_chain_tx_in_t *a_in){
json_object *l_obj_in = json_object_new_object();
json_object *l_obj_prev_idx = json_object_new_uint64(a_in->header.tx_out_prev_idx);
- char *l_hash = dap_chain_hash_fast_to_str_new(&a_in->header.tx_prev_hash);
+ char l_hash[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&a_in->header.tx_prev_hash, l_hash, sizeof(l_hash));
json_object *l_obj_hash = json_object_new_string(l_hash);
- DAP_DELETE(l_hash);
json_object_object_add(l_obj_in, "prev_idx", l_obj_prev_idx);
json_object_object_add(l_obj_in, "prev_hash", l_obj_hash);
return l_obj_in;
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index ca6438dcebd078758b47e6a4b77d2b1d0ae18200..923b4109500f7cb0d533ec08a772e98f127607b3 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -252,16 +252,17 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
"Can't find event %s in round.new - only place where could be signed the new event\n",
l_event_hash_str);
ret = -30;
- }else {
+ } else {
size_t l_event_size = l_round_item->event_size;
- dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *)DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
+ dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t*)DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
size_t l_event_size_new = dap_chain_cs_dag_event_sign_add(&l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key);
if ( l_event_size_new ) {
dap_chain_hash_fast_t l_event_new_hash;
dap_chain_cs_dag_event_calc_hash(l_event, l_event_size_new, &l_event_new_hash);
- char * l_event_new_hash_hex_str = dap_chain_hash_fast_to_str_new(&l_event_new_hash);
- char * l_event_new_hash_base58_str = dap_enc_base58_encode_hash_to_str(&l_event_new_hash);
+ char l_event_new_hash_hex_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_event_new_hash, l_event_new_hash_hex_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
+ char *l_event_new_hash_base58_str = dap_enc_base58_encode_hash_to_str(&l_event_new_hash);
bool l_event_is_ready = s_round_event_ready_minimum_check(l_dag, l_event, l_event_size_new,
l_event_new_hash_hex_str);
@@ -293,8 +294,6 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
ret=-31;
}
- DAP_DELETE(l_event);
- DAP_DELETE(l_event_new_hash_hex_str);
DAP_DELETE(l_event_new_hash_base58_str);
} else {
dap_cli_server_cmd_set_reply_text(a_str_reply,
@@ -302,6 +301,7 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
l_event_hash_str);
ret=-1;
}
+ DAP_DELETE(l_event);
DAP_DELETE(l_round_item);
}
} else {
@@ -551,31 +551,36 @@ static void s_callback_round_event_to_chain_callback_get_round_item(dap_global_d
}
}
dap_chain_cs_dag_event_round_item_t *l_chosen_item = s_round_event_choose_dup(l_dups_list, l_max_signs_count);
- dap_chain_cs_dag_event_t *l_new_atom = NULL;
if (l_chosen_item) {
size_t l_event_size = l_chosen_item->event_size;
- l_new_atom = DAP_DUP_SIZE(l_chosen_item->event_n_signs, l_event_size);
- dap_hash_fast_t l_event_hash = {};
- dap_hash_fast(l_new_atom, l_event_size, &l_event_hash);
- char l_event_hash_hex_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_hash_fast_to_str(&l_event_hash, l_event_hash_hex_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
- dap_chain_atom_verify_res_t l_res = l_dag->chain->callback_atom_add(l_dag->chain, l_new_atom, l_event_size);
- if (l_res == ATOM_PASS || l_res == ATOM_REJECT) { // Add new atom in chain
- DAP_DEL_Z(l_new_atom);
- log_it(L_DEBUG, "Event %s from round %"DAP_UINT64_FORMAT_U" not added in chain", l_event_hash_hex_str, l_arg->round_id);
- } else {
- log_it(L_NOTICE, "Event %s from round %"DAP_UINT64_FORMAT_U" added in %s successfully", l_event_hash_hex_str, l_arg->round_id,
- l_res == ATOM_ACCEPT ? "chain" : "threshold");
+ dap_chain_cs_dag_event_t *l_new_atom = (dap_chain_cs_dag_event_t *)DAP_DUP_SIZE(l_chosen_item->event_n_signs, l_event_size);
+ char *l_event_hash_hex_str, *l_datum_hash_str;
+ dap_get_data_hash_str_static(l_new_atom, l_event_size, l_event_hash_hex_str);
+ dap_chain_datum_t *l_datum = dap_chain_cs_dag_event_get_datum(l_new_atom, l_event_size);
+ dap_get_data_hash_str_static(l_datum, dap_chain_datum_size(l_datum), l_datum_hash_str);
+ int l_verify_datum = dap_chain_net_verify_datum_for_add(dap_chain_net_by_id(l_dag->chain->net_id), l_datum);
+ if (!l_verify_datum) {
+ dap_chain_atom_verify_res_t l_res = l_dag->chain->callback_atom_add(l_dag->chain, l_new_atom, l_event_size);
if (l_res == ATOM_ACCEPT) {
dap_chain_atom_save(l_dag->chain, (dap_chain_atom_ptr_t)l_new_atom, l_event_size, l_dag->chain->cells->id);
pthread_rwlock_wrlock(&l_poa_pvt->rounds_rwlock);
HASH_DEL(l_poa_pvt->active_rounds, l_arg);
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
s_poa_round_clean(l_dag->chain);
- }
+ } else if (l_res != ATOM_MOVE_TO_THRESHOLD)
+ DAP_DELETE(l_new_atom);
+ if (!l_new_atom->header.round_id)
+ l_dag->round_completed++;
+ log_it(L_INFO, "Event %s from round %"DAP_UINT64_FORMAT_U" %s",
+ l_event_hash_hex_str, l_arg->round_id, dap_chain_atom_verify_res_str[l_res]);
+ } else {
+ DAP_DELETE(l_new_atom);
+ log_it(L_INFO, "Event %s from round %"DAP_UINT64_FORMAT_U" not added into chain, because the inner datum %s doesn't pass verification (error %d)",
+ l_event_hash_hex_str, l_arg->round_id, l_datum_hash_str, l_verify_datum);
}
- } else
- log_it(L_WARNING, "No round candidates for round ID %"DAP_UINT64_FORMAT_U, l_arg->round_id);
+ } else { /* !l_chosen_item */
+ log_it(L_WARNING, "No candidates for round id %"DAP_UINT64_FORMAT_U, l_arg->round_id);
+ }
dap_list_free(l_dups_list);
DAP_DELETE(a_arg);
}
@@ -735,7 +740,7 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t *)a_value;
size_t l_event_size = l_round_item->event_size;
- dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t *)l_round_item->event_n_signs;
+ dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t*)DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
if (l_event->header.round_id < a_dag->round_completed) {
struct round_timer_arg *l_round_active;
@@ -745,6 +750,7 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
if (!l_round_active) {
log_it(L_DEBUG, "DAG event came from too old round so won't be processed");
+ DAP_DELETE(l_event);
return -2;
}
}
@@ -756,6 +762,7 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
s_round_event_ready_minimum_check(a_dag, l_event, l_event_size, (char *)a_key))
// cs done (minimum signs & verify passed)
s_round_event_cs_done(a_dag, l_event->header.round_id);
+ DAP_DELETE(l_event);
return 0;
}
@@ -764,14 +771,10 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
if (!l_poa_pvt->callback_pre_sign || !l_poa_pvt->callback_pre_sign->callback ||
!(ret = l_poa_pvt->callback_pre_sign->callback(a_dag->chain, l_event, l_event_size,
l_poa_pvt->callback_pre_sign->arg))) {
- l_event = DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
l_event_size_new = dap_chain_cs_dag_event_sign_add(&l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key);
- dap_chain_hash_fast_t l_event_new_hash;
- dap_chain_cs_dag_event_calc_hash(l_event, l_event_size_new, &l_event_new_hash);
- char *l_event_new_hash_hex_str = dap_chain_hash_fast_to_str_new(&l_event_new_hash);
+ char *l_event_new_hash_hex_str;
+ dap_get_data_hash_str_static(l_event, l_event_size_new, l_event_new_hash_hex_str);
dap_chain_cs_dag_event_gdb_set(a_dag, l_event_new_hash_hex_str, l_event, l_event_size_new, l_round_item);
- DAP_DELETE(l_event_new_hash_hex_str);
- DAP_DELETE(l_event);
} else { // set sign for reject
l_round_item = DAP_DUP_SIZE(a_value, a_value_size);
if (dap_chain_cs_dag_event_round_sign_add(&l_round_item, a_value_size, l_poa_pvt->events_sign_cert->enc_key)) {
@@ -781,6 +784,7 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
}
DAP_DELETE(l_round_item);
}
+ DAP_DELETE(l_event);
return 0;
}
diff --git a/modules/consensus/none/dap_chain_cs_none.c b/modules/consensus/none/dap_chain_cs_none.c
index 4055932edee3e28402b75516f589130858b5ec73..78a86c04eef9c92a9f6d49e256696fecd1a20a7d 100644
--- a/modules/consensus/none/dap_chain_cs_none.c
+++ b/modules/consensus/none/dap_chain_cs_none.c
@@ -45,11 +45,10 @@
#define CONSENSUS_NAME "none"
typedef struct dap_chain_gdb_datum_hash_item{
- char key[70];
+ char key[DAP_CHAIN_HASH_FAST_STR_SIZE];
dap_chain_hash_fast_t datum_data_hash;
uint8_t padding[2];
- struct dap_chain_gdb_datum_hash_item * prev;
- struct dap_chain_gdb_datum_hash_item * next;
+ struct dap_chain_gdb_datum_hash_item *prev, *next;
} dap_chain_gdb_datum_hash_item_t;
typedef struct dap_chain_gdb_private
@@ -457,9 +456,8 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
*/
static void s_chain_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter)
{
- if (a_atom_iter->cur_item)
- DAP_DELETE(a_atom_iter->cur_item);
- DAP_DELETE(a_atom_iter->cur_hash);
+ DAP_DEL_Z(a_atom_iter->cur_item);
+ DAP_DEL_Z(a_atom_iter->cur_hash);
DAP_DELETE(a_atom_iter);
}
@@ -475,12 +473,13 @@ static void s_chain_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_ite
static dap_chain_atom_ptr_t s_chain_callback_atom_iter_find_by_hash(dap_chain_atom_iter_t * a_atom_iter,
dap_chain_hash_fast_t * a_atom_hash, size_t *a_atom_size)
{
- char * l_key = dap_chain_hash_fast_to_str_new(a_atom_hash);
+ char l_key[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(a_atom_hash, l_key, sizeof(l_key));
size_t l_ret_size;
dap_chain_atom_ptr_t l_ret = NULL;
- dap_chain_gdb_t * l_gdb = DAP_CHAIN_GDB(a_atom_iter->chain );
- if(l_gdb){
- l_ret = dap_global_db_get_sync(PVT ( l_gdb )->group_datums,l_key,&l_ret_size,NULL, NULL );
+ dap_chain_gdb_t *l_gdb = DAP_CHAIN_GDB(a_atom_iter->chain);
+ if (l_gdb) {
+ l_ret = dap_global_db_get_sync(PVT(l_gdb)->group_datums, l_key, &l_ret_size, NULL, NULL);
*a_atom_size = l_ret_size;
}
return l_ret;
@@ -497,19 +496,18 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_first(dap_chain_atom_
{
if (!a_atom_iter)
return NULL;
- if (a_atom_iter->cur_item) {// This iterator should clean up data for it because its allocate it
+ if (a_atom_iter->cur_item) { /* Iterator creates copies, free them at delete routine! */
DAP_DEL_Z(a_atom_iter->cur);
DAP_DEL_Z(a_atom_iter->cur_hash);
}
dap_chain_datum_t * l_datum = NULL;
dap_chain_gdb_datum_hash_item_t *l_item = PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->hash_items;
a_atom_iter->cur_item = l_item;
- if (a_atom_iter->cur_item ){
- size_t l_datum_size =0;
- l_datum= (dap_chain_datum_t*) dap_global_db_get_sync(PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->group_datums, l_item->key, &l_datum_size,
- NULL, NULL );
- if (a_atom_iter->cur) // This iterator should clean up data for it because its allocate it
- DAP_DELETE( a_atom_iter->cur);
+ if (a_atom_iter->cur_item) {
+ size_t l_datum_size = 0;
+ l_datum = (dap_chain_datum_t*)dap_global_db_get_sync(PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->group_datums,
+ l_item->key, &l_datum_size, NULL, NULL);
+ DAP_DEL_Z(a_atom_iter->cur);
a_atom_iter->cur = l_datum;
a_atom_iter->cur_size = l_datum_size;
a_atom_iter->cur_hash = DAP_NEW_Z(dap_hash_fast_t);
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 02a73ef488975b7198ad8748302de5e31d88866b..e7807cd696e953a5b10bde866093c132c1b88734 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -95,11 +95,9 @@ char *dap_chain_mempool_datum_add(const dap_chain_datum_t *a_datum, dap_chain_t
dap_chain_hash_fast_t l_key_hash;
dap_hash_fast(a_datum->data, a_datum->header.data_size, &l_key_hash);
- char *l_key_str;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
- else
- l_key_str = dap_enc_base58_encode_hash_to_str(&l_key_hash);
+ char *l_key_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_key_hash)
+ : dap_chain_hash_fast_to_str_new(&l_key_hash);
const char *l_type_str;
switch (a_datum->header.type_id) {
@@ -123,8 +121,7 @@ char *dap_chain_mempool_datum_add(const dap_chain_datum_t *a_datum, dap_chain_t
else
log_it(L_WARNING, "Can't place datum %s with hash %s in mempool group %s", l_type_str, l_key_str, l_gdb_group);
DAP_DELETE(l_gdb_group);
-
- return (l_res == DAP_GLOBAL_DB_RC_SUCCESS) ? l_key_str : NULL;
+ return (l_res == DAP_GLOBAL_DB_RC_SUCCESS) ? l_key_str : ({ DAP_DELETE(l_key_str); NULL; });
}
/**
@@ -561,12 +558,11 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
l_objs[i].value_len = dap_chain_datum_size(l_datum);
log_it(L_DEBUG, "Prepared obj with key %s (value_len = %"DAP_UINT64_FORMAT_U")",
l_objs[i].key? l_objs[i].key :"NULL" , l_objs[i].value_len );
-
}
dap_list_free_full(l_list_used_out, free);
- char * l_gdb_group = dap_chain_net_get_gdb_group_mempool_new(a_chain);
- dap_global_db_set_multiple_zc(l_gdb_group, l_objs,a_tx_num, s_tx_create_massive_gdb_save_callback , NULL );
+ char *l_gdb_group = dap_chain_net_get_gdb_group_mempool_new(a_chain);
+ dap_global_db_set_multiple_zc(l_gdb_group, l_objs, a_tx_num, s_tx_create_massive_gdb_save_callback, NULL);
DAP_DELETE(l_gdb_group);
return 0;
}
@@ -1130,8 +1126,8 @@ void chain_mempool_proc(struct dap_http_simple *cl_st, void * arg)
http_status_code_t * return_code = (http_status_code_t*) arg;
// save key while it alive, i.e. still exist
dap_enc_key_t *l_enc_key = dap_enc_ks_find_http(cl_st->http_client);
- //dap_enc_key_serealize_t *key_ser = dap_enc_key_serealize(key_tmp);
- //dap_enc_key_t *key = dap_enc_key_deserealize(key_ser, sizeof(dap_enc_key_serealize_t));
+ //dap_enc_key_serialize_t *key_ser = dap_enc_key_serialize(key_tmp);
+ //dap_enc_key_t *key = dap_enc_key_deserialize(key_ser, sizeof(dap_enc_key_serialize_t));
// read header
dap_http_header_t *hdr_session_close_id =
@@ -1249,12 +1245,12 @@ void dap_chain_mempool_add_proc(dap_http_t * a_http_server, const char * a_url)
* @param a_removed Pointer to a variable of type int which will store how many remote datums.
*/
void dap_chain_mempool_filter(dap_chain_t *a_chain, int *a_removed){
- int l_removed = 0;
if (!a_chain) {
- if (!a_removed)
- *a_removed = l_removed;
+ if (a_removed)
+ *a_removed = 0;
return;
}
+ int l_removed = 0;
char * l_gdb_group = dap_chain_net_get_gdb_group_mempool_new(a_chain);
size_t l_objs_size = 0;
dap_time_t l_cut_off_time = dap_time_now() - 2592000; // 2592000 sec = 30 days
@@ -1263,6 +1259,12 @@ void dap_chain_mempool_filter(dap_chain_t *a_chain, int *a_removed){
dap_global_db_obj_t * l_objs = dap_global_db_get_all_sync(l_gdb_group, &l_objs_size);
for (size_t i = 0; i < l_objs_size; i++) {
dap_chain_datum_t *l_datum = (dap_chain_datum_t*)l_objs[i].value;
+ if (!l_datum) {
+ l_removed++;
+ log_it(L_NOTICE, "Removed datum from mempool with \"%s\" key group %s: empty (possibly trash) value", l_objs[i].key, l_gdb_group);
+ dap_global_db_del_sync(l_objs[i].key, l_gdb_group);
+ continue;
+ }
size_t l_datum_size = dap_chain_datum_size(l_datum);
//Filter data size
if (l_datum_size != l_objs[i].value_len) {
@@ -1273,18 +1275,15 @@ void dap_chain_mempool_filter(dap_chain_t *a_chain, int *a_removed){
continue;
}
//Filter hash
- dap_hash_fast_t l_hash_content = {0};
- dap_hash_fast(l_datum->data, l_datum->header.data_size, &l_hash_content);
- char *l_hash_content_str = dap_hash_fast_to_str_new(&l_hash_content);
+ char *l_hash_content_str;
+ dap_get_data_hash_str_static(l_datum->data, l_datum->header.data_size, l_hash_content_str);
if (dap_strcmp(l_hash_content_str, l_objs[i].key) != 0) {
l_removed++;
- DAP_DELETE(l_hash_content_str);
log_it(L_NOTICE, "Removed datum from mempool with \"%s\" key group %s. The hash of the contents of the "
"datum does not match the key.", l_objs[i].key, l_gdb_group);
dap_global_db_del_sync(l_gdb_group, l_objs[i].key);
continue;
}
- DAP_DELETE(l_hash_content_str);
//Filter time
if (l_datum->header.ts_create < l_cut_off_time) {
l_removed++;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 3271a57714dd5fb6d2b55da3be3302a36c30176a..e10e6cc40966b4b2678c9b6174d28f92b90ff36b 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -1996,21 +1996,25 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
dap_cert_t * l_cert = dap_cert_find_by_name(l_cert_string);
if (l_cert == NULL) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find \"%s\" certificate", l_cert_string);
+ DAP_DEL_Z(l_hash_hex_str);
return -7;
}
if (l_cert->enc_key == NULL) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "No key found in \"%s\" certificate", l_cert_string );
+ DAP_DEL_Z(l_hash_hex_str);
return -8;
}
// Get publivc key hash
size_t l_pub_key_size = 0;
- uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(l_cert->enc_key, &l_pub_key_size);;
+ uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(l_cert->enc_key, &l_pub_key_size);;
if (l_pub_key == NULL) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't serialize public key of certificate \"%s\"", l_cert_string);
+ DAP_DEL_Z(l_hash_hex_str);
return -9;
}
dap_chain_hash_fast_t l_pkey_hash;
dap_hash_fast(l_pub_key, l_pub_key_size, &l_pkey_hash);
+ DAP_DEL_Z(l_hash_hex_str);
l_hash_hex_str = dap_chain_hash_fast_to_str_new(&l_pkey_hash);
//l_hash_base58_str = dap_enc_base58_encode_hash_to_str(&l_pkey_hash);
}
@@ -2265,7 +2269,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
char **l_seed_aliases = dap_config_get_array_str(l_cfg, "general", "seed_nodes_aliases",
&l_net_pvt->seed_aliases_count);
if (l_net_pvt->seed_aliases_count)
- l_net_pvt->seed_aliases = (char **)DAP_NEW_SIZE(char *, sizeof(char *) * l_net_pvt->seed_aliases_count);
+ l_net_pvt->seed_aliases = DAP_NEW_Z_SIZE(char*, sizeof(char*) * l_net_pvt->seed_aliases_count);
for(size_t i = 0; i < l_net_pvt->seed_aliases_count; i++)
l_net_pvt->seed_aliases[i] = dap_strdup(l_seed_aliases[i]);
// randomize seed nodes list
@@ -2338,7 +2342,7 @@ int s_net_init(const char * a_net_name, uint16_t a_acl_idx)
if(l_certs_size > 0)
l_cert = l_certs[0];
if(l_cert) {
- l_pub_key_data = dap_enc_key_serealize_pub_key(l_cert->enc_key, &l_pub_key_data_size);
+ l_pub_key_data = dap_enc_key_serialize_pub_key(l_cert->enc_key, &l_pub_key_data_size);
// save pub key
if(l_pub_key_data && l_pub_key_data_size > 0)
dap_global_db_set(GROUP_LOCAL_NODE_ADDR, l_addr_key, l_pub_key_data, l_pub_key_data_size, false,
@@ -3101,7 +3105,6 @@ void s_proc_mempool_callback_load(dap_global_db_context_t *a_global_db_context,
{
dap_chain_t * l_chain = (dap_chain_t*) a_arg;
dap_chain_net_t * l_net = dap_chain_net_by_id( l_chain->net_id );
- dap_string_t * l_str_tmp = dap_string_new(NULL);
if(a_values_count) {
log_it(L_INFO, "%s.%s: Found %zu records :", l_net->pub.name, l_chain->name,
a_values_count);
@@ -3111,13 +3114,20 @@ void s_proc_mempool_callback_load(dap_global_db_context_t *a_global_db_context,
size_t l_objs_size_tmp = (a_values_count > 15) ? min(a_values_count, 10) : a_values_count;
for(size_t i = 0; i < a_values_count; i++) {
dap_chain_datum_t * l_datum = (dap_chain_datum_t*) a_values[i].value;
- int l_verify_datum= dap_chain_net_verify_datum_for_add( l_net, l_datum) ;
+ int l_dup_or_skip = dap_chain_datum_unledgered_search_iter(l_datum, l_chain);
+ if (l_dup_or_skip) {
+ log_it(L_WARNING, "Datum unledgered search returned '%d', delete it from mempool", l_dup_or_skip);
+ dap_global_db_del_unsafe(a_global_db_context, a_group, a_values[i].key);
+ l_datums[i] = NULL;
+ continue;
+ }
+
+ int l_verify_datum = dap_chain_net_verify_datum_for_add( l_net, l_datum) ;
if (l_verify_datum != 0){
- log_it(L_WARNING, "Datum doesn't pass verifications (code %d), delete such datum from pool",
- l_verify_datum);
- dap_global_db_del_unsafe( a_global_db_context, a_group, a_values[i].key);
+ log_it(L_WARNING, "Datum doesn't pass verifications (code %d), delete such datum from pool", l_verify_datum);
+ dap_global_db_del_unsafe(a_global_db_context, a_group, a_values[i].key);
l_datums[i] = NULL;
- }else{
+ } else {
l_datums[i] = l_datum;
if(i < l_objs_size_tmp) {
char buf[50] = { '\0' };
@@ -3133,28 +3143,22 @@ void s_proc_mempool_callback_load(dap_global_db_context_t *a_global_db_context,
size_t l_objs_processed = l_chain->callback_add_datums(l_chain, l_datums, l_datums_size);
// Delete processed objects
size_t l_objs_processed_tmp = (l_objs_processed > 15) ? min(l_objs_processed, 10) : l_objs_processed;
- for(size_t i = 0; i < l_objs_processed; i++) {
- dap_global_db_del_unsafe(a_global_db_context, a_group, a_values[i].key );
- if(i < l_objs_processed_tmp) {
- dap_string_append_printf(l_str_tmp, "New event created, removed datum 0x%s from mempool \n",
- a_values[i].key);
- }
+ for (size_t i = 0; i < l_objs_processed; i++) {
+ dap_global_db_del_unsafe(a_global_db_context, a_group, a_values[i].key);
+ log_it(L_WARNING, "New event created, removed datum 0x%s from mempool \n", a_values[i].key);
}
- if(l_objs_processed < l_datums_size)
- log_it(L_WARNING, "%s.%s: %zu records not processed", l_net->pub.name, l_chain->name,
- l_datums_size - l_objs_processed);
+ debug_if(l_objs_processed < l_datums_size, L_WARNING, "%s.%s: %zu records not processed",
+ l_net->pub.name, l_chain->name, l_datums_size - l_objs_processed);
dap_global_db_objs_delete(a_values, a_values_count);
// Cleanup datums array
- if(l_datums){
- for(size_t i = 0; i < a_values_count; i++) {
- if (l_datums[i])
- DAP_DELETE(l_datums[i]);
+ if (l_datums){
+ for (size_t i = 0; i < a_values_count; i++) {
+ DAP_DEL_Z(l_datums[i]);
}
- DAP_DEL_Z(l_datums);
+ DAP_DELETE(l_datums);
}
- }
- else {
+ } else {
log_it(L_INFO, "%s.%s: No records in mempool", l_net->pub.name, l_chain ? l_chain->name : "[no chain]");
}
}
@@ -3246,7 +3250,8 @@ static bool s_net_check_acl(dap_chain_net_t *a_net, dap_chain_hash_fast_t *a_pke
return false;
}
l_authorized = false;
- const char *l_auth_hash_str = dap_chain_hash_fast_to_str_new(a_pkey_hash);
+ char l_auth_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(a_pkey_hash, l_auth_hash_str, sizeof(l_auth_hash_str));
uint16_t l_acl_list_len = 0;
char **l_acl_list = dap_config_get_array_str(l_cfg, "auth", "acl_accept_ca_list", &l_acl_list_len);
for (uint16_t i = 0; i < l_acl_list_len; i++) {
@@ -3273,16 +3278,14 @@ static bool s_net_check_acl(dap_chain_net_t *a_net, dap_chain_hash_fast_t *a_pke
const char *l_acl_chains = dap_config_get_item_str(l_cfg, "auth", "acl_accept_ca_chains");
if (l_acl_chains && !strcmp(l_acl_chains, "all")) {
dap_list_t *l_certs = dap_cert_get_all_mem();
- for (dap_list_t *l_tmp = l_certs; l_tmp; l_tmp = dap_list_next(l_tmp)) {
+ for (dap_list_t *l_tmp = l_certs; l_tmp && !l_authorized; l_tmp = dap_list_next(l_tmp)) {
dap_cert_t *l_cert = (dap_cert_t *)l_tmp->data;
size_t l_pkey_size;
- uint8_t *l_pkey_ser = dap_enc_key_serealize_pub_key(l_cert->enc_key, &l_pkey_size);
+ uint8_t *l_pkey_ser = dap_enc_key_serialize_pub_key(l_cert->enc_key, &l_pkey_size);
dap_chain_hash_fast_t l_cert_hash;
dap_hash_fast(l_pkey_ser, l_pkey_size, &l_cert_hash);
if (!memcmp(&l_cert_hash, a_pkey_hash, sizeof(dap_chain_hash_fast_t))) {
l_authorized = true;
- DAP_DELETE(l_pkey_ser);
- break;
}
DAP_DELETE(l_pkey_ser);
}
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index d1dc0ec17783b9a2360a52fa98e58fd67352aa0e..9ca79342b1ae4e7d4fe02f9d4c0b4b8bf667b32d 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -45,6 +45,7 @@
#include "dap_chain_net.h"
#include "dap_global_db.h"
#include "dap_chain_node.h"
+#include "dap_chain_cell.h"
#define LOG_TAG "chain_node"
@@ -94,9 +95,8 @@ bool dap_chain_node_alias_register(dap_chain_net_t *a_net, const char *a_alias,
dap_chain_node_addr_t * dap_chain_node_alias_find(dap_chain_net_t * a_net,const char *a_alias)
{
size_t l_addr_size =0;
- dap_chain_node_addr_t * l_addr = (dap_chain_node_addr_t *)
- dap_global_db_get_sync(a_net->pub.gdb_nodes_aliases, a_alias, &l_addr_size, NULL, NULL );
- return l_addr;
+ return (dap_chain_node_addr_t*)dap_global_db_get_sync(a_net->pub.gdb_nodes_aliases,
+ a_alias, &l_addr_size, NULL, NULL);
}
/**
@@ -104,7 +104,7 @@ dap_chain_node_addr_t * dap_chain_node_alias_find(dap_chain_net_t * a_net,const
*/
bool dap_chain_node_alias_delete(dap_chain_net_t * a_net,const char *a_alias)
{
- return dap_global_db_del_sync(a_net->pub.gdb_nodes_aliases, a_alias) == 0;
+ return dap_global_db_del_sync(a_net->pub.gdb_nodes_aliases, a_alias) == 0;
}
/**
@@ -205,11 +205,12 @@ bool dap_chain_node_mempool_need_process(dap_chain_t *a_chain, dap_chain_datum_t
return false;
}
-// Return true if processed datum should be deleted from mempool
+/* Return true if processed datum should be deleted from mempool */
bool dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_datum) {
if (!a_chain->callback_add_datums)
return false;
- // Verify for correctness
+ if (dap_chain_datum_unledgered_search_iter(a_datum, a_chain))
+ return true; /* Already chained, no need to keep duplicates */
dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
int l_verify_datum = dap_chain_net_verify_datum_for_add(l_net, a_datum);
if (l_verify_datum != 0 &&
@@ -222,7 +223,9 @@ bool dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_d
|| l_verify_datum == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS
#endif
)
+ {
a_chain->callback_add_datums(a_chain, &a_datum, 1);
+ }
return false;
}
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 8bcda383b7883e6bf6e0144f731c137c36b20d77..e2dbf64a85887bc43a566b0884271063d0829de3 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -882,20 +882,16 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
switch (l_subcmd) {
case SUMCMD_GET: // Get value
{
- dap_hash_fast_t l_hash;
- char *l_hash_str = NULL;
- if(dap_hash_fast(l_value, l_value_len, &l_hash)) {
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_hash);
- }
+ char *l_hash_str;
+ dap_get_data_hash_str_static(l_value, l_value_len, l_hash_str);
char *l_value_str = DAP_NEW_Z_SIZE(char, l_value_len * 2 + 2);
- //size_t ret = dap_bin2hex(l_value_str, l_value, l_value_len);
+ size_t ret = dap_bin2hex(l_value_str, l_value, l_value_len);
dap_cli_server_cmd_set_reply_text(a_str_reply, "Record found\n"
"lenght:\t%zu byte\n"
"hash:\t%s\n"
"pinned:\t%s\n"
"value:\t0x%s\n\n", l_value_len, l_hash_str, l_is_pinned ? "Yes" : "No", l_value_str);
DAP_DELETE(l_value_str);
- DAP_DELETE(l_hash_str);
break;
}
case SUMCMD_PIN: // Pin record
@@ -2257,8 +2253,7 @@ int com_token_decl_sign(int a_argc, char **a_argv, char ** a_str_reply)
// Chain name
dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-datum", &l_datum_hash_str);
if(l_datum_hash_str) {
- char * l_datum_hash_hex_str = NULL;
- char * l_datum_hash_base58_str = NULL;
+ char *l_datum_hash_hex_str = NULL, *l_datum_hash_base58_str = NULL;
const char * l_certs_str = NULL;
dap_cert_t ** l_certs = NULL;
size_t l_certs_count = 0;
@@ -2355,16 +2350,12 @@ int com_token_decl_sign(int a_argc, char **a_argv, char ** a_str_reply)
DAP_DELETE(l_datum_token);
// Calc datum's hash
l_datum_size = dap_chain_datum_size(l_datum);
- dap_chain_hash_fast_t l_key_hash={};
+ dap_chain_hash_fast_t l_key_hash = { };
dap_hash_fast(l_datum->data, l_token_size, &l_key_hash);
char * l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
char * l_key_str_base58 = dap_enc_base58_encode_hash_to_str(&l_key_hash);
- const char * l_key_out_str;
- if(!dap_strcmp(l_hash_out_type,"hex"))
- l_key_out_str = l_key_str;
- else
- l_key_out_str = l_key_str_base58;
-
+ const char *l_key_out_str = dap_strcmp(l_hash_out_type,"hex")
+ ? l_key_str_base58 : l_key_str;
// Add datum to mempool with datum_token hash as a key
if( dap_global_db_set_sync(l_gdb_group_mempool, l_key_str, l_datum, dap_chain_datum_size(l_datum), true) == 0) {
@@ -2374,7 +2365,8 @@ int com_token_decl_sign(int a_argc, char **a_argv, char ** a_str_reply)
dap_cli_server_cmd_set_reply_text(a_str_reply,
"datum %s is replacing the %s in datum pool",
l_key_out_str, l_datum_hash_out_str);
-
+ DAP_DELETE(l_key_str);
+ DAP_DELETE(l_key_str_base58);
DAP_DELETE(l_datum);
//DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
@@ -2383,6 +2375,8 @@ int com_token_decl_sign(int a_argc, char **a_argv, char ** a_str_reply)
dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't remove old datum %s ( new datum %s added normaly in datum pool)",
l_datum_hash_out_str, l_key_out_str);
+ DAP_DELETE(l_key_str);
+ DAP_DELETE(l_key_str_base58);
DAP_DELETE(l_datum);
//DAP_DELETE(l_datum_token);
DAP_DELETE(l_gdb_group_mempool);
@@ -2967,13 +2961,13 @@ int com_mempool_proc(int a_argc, char **a_argv, char **a_str_reply)
dap_chain_datum_t * l_datum = l_datum_hash_hex_str ? (dap_chain_datum_t*) dap_global_db_get_sync(l_gdb_group_mempool, l_datum_hash_hex_str,
&l_datum_size, NULL, NULL ) : NULL;
- size_t l_datum_size2= l_datum? dap_chain_datum_size( l_datum): 0;
- if (l_datum_size != l_datum_size2 ){
+ size_t l_datum_size2 = l_datum? dap_chain_datum_size( l_datum): 0;
+ if (l_datum_size != l_datum_size2) {
ret = -8;
dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! Corrupted datum %s, size by datum headers is %zd when in mempool is only %zd bytes",
l_datum_hash_hex_str, l_datum_size2, l_datum_size);
- }else{
- if(l_datum) {
+ } else {
+ if (l_datum) {
char buf[50];
dap_time_t l_ts_create = (dap_time_t)l_datum->header.ts_create;
const char *l_type = NULL;
@@ -2982,25 +2976,33 @@ int com_mempool_proc(int a_argc, char **a_argv, char **a_str_reply)
l_datum_hash_out_str, l_type,
dap_ctime_r(&l_ts_create, buf), l_datum->header.data_size);
int l_verify_datum= dap_chain_net_verify_datum_for_add( l_net, l_datum) ;
- if (l_verify_datum != 0){
- dap_string_append_printf(l_str_tmp, "Error! Datum doesn't pass verifications (code %d) examine node log files",
- l_verify_datum);
- ret = -9;
- }else{
- if (l_chain->callback_add_datums){
- if (l_chain->callback_add_datums(l_chain, &l_datum, 1) ==0 ){
- dap_string_append_printf(l_str_tmp, "Error! Datum doesn't pass verifications, examine node log files");
- ret = -6;
- }else{
- dap_string_append_printf(l_str_tmp, "Datum processed well. ");
- /*if ( dap_global_db_del_sync( l_gdb_group_mempool, l_datum_hash_hex_str) != 0){
- dap_string_append_printf(l_str_tmp, "Warning! Can't delete datum from mempool!");
- }else
- dap_string_append_printf(l_str_tmp, "Removed datum from mempool.");*/
+ int l_dup_or_skip = dap_chain_datum_unledgered_search_iter(l_datum, l_chain);
+ if (l_dup_or_skip) {
+ dap_string_append_printf(l_str_tmp, "Error! Datum unledgered search returned '%d'", l_dup_or_skip);
+ dap_global_db_del_sync(l_datum_hash_hex_str, l_gdb_group_mempool);
+ ret = -10;
+ } else {
+ int l_verify_datum = dap_chain_net_verify_datum_for_add( l_net, l_datum) ;
+ if (l_verify_datum != 0){
+ dap_string_append_printf(l_str_tmp, "Error! Datum doesn't pass verifications (code %d) examine node log files",
+ l_verify_datum);
+ ret = -9;
+ } else {
+ if (l_chain->callback_add_datums) {
+ if (l_chain->callback_add_datums(l_chain, &l_datum, 1) == 0) {
+ dap_string_append_printf(l_str_tmp, "Error! Datum doesn't pass verifications, examine node log files");
+ ret = -6;
+ } else {
+ dap_string_append_printf(l_str_tmp, "Datum processed well. ");
+ if (!dap_global_db_del_sync(l_datum_hash_hex_str, l_gdb_group_mempool)){
+ dap_string_append_printf(l_str_tmp, "Warning! Can't delete datum from mempool!");
+ } else
+ dap_string_append_printf(l_str_tmp, "Removed datum from mempool.");
+ }
+ } else {
+ dap_string_append_printf(l_str_tmp, "Error! Can't move to no-concensus chains from mempool");
+ ret = -1;
}
- }else{
- dap_string_append_printf(l_str_tmp, "Error! Can't move to no-concensus chains from mempool");
- ret = -1;
}
}
dap_string_append_printf(l_str_tmp, "\n");
@@ -3036,9 +3038,8 @@ int com_mempool_proc_all(int argc, char ** argv, char ** a_str_reply) {
dap_chain_node_cli_cmd_values_parse_net_chain(&arg_index, argc, argv, a_str_reply, &l_chain, &l_net);
if (!l_net || !l_chain)
return -1;
- char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
- if(!l_gdb_group_mempool) {
+ if(!dap_chain_net_by_id(l_chain->net_id)) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s.%s: chain not found\n", l_net->pub.name,
l_chain->name);
}
@@ -3685,31 +3686,24 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
dap_enc_base58_encode_hash_to_str(&l_key_hash) : l_key_str;
// Add datum to mempool with datum_token hash as a key
- char * l_gdb_group_mempool;
- if (l_chain)
- l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
- else
- l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_by_chain_type(l_net, CHAIN_TYPE_TOKEN);
+ char *l_gdb_group_mempool = l_chain
+ ? dap_chain_net_get_gdb_group_mempool_new(l_chain)
+ : dap_chain_net_get_gdb_group_mempool_by_chain_type(l_net, CHAIN_TYPE_TOKEN);
if (!l_gdb_group_mempool) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "No suitable chain for placing token datum found");
+ DAP_DEL_Z(l_key_str);
+ DAP_DEL_Z(l_key_str_out);
DAP_DELETE(l_datum);
return -10;
}
- int l_ret = 0;
bool l_placed = dap_global_db_set_sync(l_gdb_group_mempool, l_key_str, l_datum, l_datum_size, true) == 0;
dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s with token %s is%s placed in datum pool",
l_key_str_out, l_ticker, l_placed ? "" : " not");
- //additional checking for incorrect key format
- if (l_key_str_out != l_key_str)
- DAP_DELETE(l_key_str);
- else
- DAP_DELETE(l_key_str);
+ DAP_DEL_Z(l_key_str);
+ DAP_DEL_Z(l_key_str_out);
DAP_DELETE(l_datum);
DAP_DELETE(l_params);
- if (!l_placed) {
- l_ret = -2;
- }
- return l_ret;
+ return l_placed ? 0 : -2;
}
/**
@@ -3886,30 +3880,24 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
dap_enc_base58_encode_hash_to_str(&l_key_hash) : l_key_str;
// Add datum to mempool with datum_token hash as a key
- char * l_gdb_group_mempool;
- if (!l_chain)
- dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_TOKEN);
- l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
+ char *l_gdb_group_mempool = l_chain
+ ? dap_chain_net_get_gdb_group_mempool_new(l_chain)
+ : dap_chain_net_get_gdb_group_mempool_by_chain_type(l_net, CHAIN_TYPE_TOKEN);
if (!l_gdb_group_mempool) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "No suitable chain for placing token datum found");
+ DAP_DEL_Z(l_key_str);
+ DAP_DEL_Z(l_key_str_out);
DAP_DELETE(l_datum);
return -10;
}
- int l_ret = 0;
bool l_placed = !dap_global_db_set_sync(l_gdb_group_mempool, l_key_str, (uint8_t *)l_datum, l_datum_size, false);
dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s with 256bit token %s is%s placed in datum pool",
l_key_str_out, l_ticker, l_placed ? "" : " not");
- //additional checking for incorrect key format
- if (l_key_str_out != l_key_str)
- DAP_DELETE(l_key_str);
- else
- DAP_DELETE(l_key_str);
+ DAP_DEL_Z(l_key_str);
+ DAP_DEL_Z(l_key_str_out);
DAP_DELETE(l_datum);
DAP_DELETE(l_params);
- if (!l_placed) {
- l_ret = -2;
- }
- return l_ret;
+ return l_placed ? 0 : -2;
}
/**
@@ -4956,21 +4944,18 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
// Add transaction to mempool
char *l_gdb_group_mempool_base_tx = dap_chain_net_get_gdb_group_mempool_new(l_chain);// get group name for mempool
- dap_chain_hash_fast_t *l_datum_tx_hash = DAP_NEW(dap_hash_fast_t);
- dap_hash_fast(l_datum_tx->data, l_datum_tx->header.data_size, l_datum_tx_hash);// Calculate datum hash
- char *l_tx_hash_str = dap_chain_hash_fast_to_str_new(l_datum_tx_hash);
+ char *l_tx_hash_str;
+ dap_get_data_hash_str_static(l_datum_tx->data, l_datum_tx->header.data_size, l_tx_hash_str);
bool l_placed = !dap_global_db_set(l_gdb_group_mempool_base_tx,l_tx_hash_str, l_datum_tx, l_datum_tx_size, true, NULL, NULL);
DAP_DELETE(l_datum_tx);
DAP_DELETE(l_gdb_group_mempool_base_tx);
if(!l_placed) {
- DAP_DELETE(l_tx_hash_str);
dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't add transaction to mempool");
return -90;
}
// Completed successfully
dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s with %zu items created and added to mempool successfully", l_tx_hash_str, l_items_ready);
- DAP_DELETE(l_tx_hash_str);
return l_err_code;
}
@@ -6259,7 +6244,6 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str
return -1;
}
-
dap_chain_net_t *l_network = dap_chain_net_by_name(l_opts_sign[OPT_NET]);
if (!l_network) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s network not found", l_opts_sign[OPT_NET]);
@@ -6279,30 +6263,21 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str
l_ret = s_get_key_from_file(l_opts_sign[OPT_FILE], l_opts_sign[OPT_MIME], l_opts_sign[OPT_CERT], &l_sign);
if (!l_ret) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s cert not found", l_opts_sign[OPT_CERT]);
- l_ret = -1;
- goto end;
+ return -1;
}
-
-
l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_SIGNER, l_sign->pkey_n_sign, l_sign->header.sign_size);
if (!l_datum) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "not created datum");
- l_ret = -1;
- goto end;
+ return -1;
}
l_ret = l_chain->callback_add_datums(l_chain, &l_datum, 1);
- dap_hash_fast_t l_hash;
- dap_hash_fast(l_datum->data, l_datum->header.data_size, &l_hash);
- char *l_key_str = dap_chain_hash_fast_to_str_new(&l_hash);
+ char *l_key_str;
+ dap_get_data_hash_str_static(l_datum->data, l_datum->header.data_size, l_key_str);
dap_cli_server_cmd_set_reply_text(a_str_reply, "hash: %s", l_key_str);
- DAP_FREE(l_key_str);
-end:
-
- if (l_datum) DAP_FREE(l_datum);
-
+ DAP_DELETE(l_datum);
return l_ret;
}
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index 645d11650aeab964105b018b09763fec038083fb..b44d3e5d57e55f9edc262ba5ba4a2838752d6aee 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -127,27 +127,22 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
dap_chain_datum_tx_t *l_tx = a_chain->callback_tx_find_by_hash(a_chain, a_tx_hash, &l_atom_hash);
if (l_tx) {
- char *l_atom_hash_str;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_atom_hash_str = dap_chain_hash_fast_to_str_new(&l_atom_hash);
- else
- l_atom_hash_str = dap_enc_base58_encode_hash_to_str(&l_atom_hash);
+ char *l_atom_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_atom_hash)
+ : dap_chain_hash_fast_to_str_new(&l_atom_hash);
const char *l_tx_token_ticker = dap_chain_ledger_tx_get_token_ticker_by_hash(a_chain->ledger, a_tx_hash);
dap_string_append_printf(l_str_out, "%s TX with atom %s\n", l_tx_token_ticker ? "ACCEPTED" : "DECLINED",
l_atom_hash_str);
DAP_DELETE(l_atom_hash_str);
dap_chain_datum_dump_tx(l_tx, l_tx_token_ticker, l_str_out, a_hash_out_type, a_tx_hash);
} else {
- char *l_tx_hash_str;
- if (!dap_strcmp(a_hash_out_type, "hex"))
- l_tx_hash_str = dap_chain_hash_fast_to_str_new(a_tx_hash);
- else
- l_tx_hash_str = dap_enc_base58_encode_hash_to_str(a_tx_hash);
+ char *l_tx_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(a_tx_hash)
+ : dap_chain_hash_fast_to_str_new(a_tx_hash);
dap_string_append_printf(l_str_out, "TX hash %s not founds in chains", l_tx_hash_str);
DAP_DELETE(l_tx_hash_str);
}
- char *l_ret_str = l_str_out ? dap_string_free(l_str_out, false) : NULL;
- return l_ret_str;
+ return l_str_out ? dap_string_free(l_str_out, false) : NULL;
}
static void s_tx_header_print(dap_string_t *a_str_out, dap_chain_tx_hash_processed_ht_t *a_tx_data_ht,
@@ -395,14 +390,13 @@ char* dap_db_history_addr(dap_chain_addr_t *a_addr, dap_chain_t *a_chain, const
// go to next atom (event or block)
l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
}
-
+ a_chain->callback_atom_iter_delete(l_atom_iter);
// delete hashes
s_dap_chain_tx_hash_processed_ht_free(l_tx_data_ht);
// if no history
if(!l_str_out->len)
dap_string_append(l_str_out, "\tempty");
- char *l_ret_str = l_str_out ? dap_string_free(l_str_out, false) : NULL;
- return l_ret_str;
+ return l_str_out ? dap_string_free(l_str_out, false) : NULL;
}
/**
diff --git a/modules/net/include/dap_chain_net.h b/modules/net/include/dap_chain_net.h
index 0393bb10237a6003bcafbaa8c4b0ec41a0b1759c..5f191f9b6c0873bb78609833328f7b4dd891cdaf 100644
--- a/modules/net/include/dap_chain_net.h
+++ b/modules/net/include/dap_chain_net.h
@@ -166,17 +166,17 @@ dap_chain_node_role_t dap_chain_net_get_role(dap_chain_net_t * a_net);
DAP_STATIC_INLINE char *dap_chain_net_get_gdb_group_mempool_new(dap_chain_t *a_chain)
{
dap_chain_net_t *l_net = a_chain ? dap_chain_net_by_id(a_chain->net_id) : NULL;
- if ( l_net )
- return dap_strdup_printf("%s.chain-%s.mempool", l_net->pub.gdb_groups_prefix,a_chain->name);
- return NULL;
+ return l_net
+ ? dap_strdup_printf("%s.chain-%s.mempool", l_net->pub.gdb_groups_prefix,a_chain->name)
+ : NULL;
}
DAP_STATIC_INLINE char *dap_chain_net_get_gdb_group_from_chain_new(dap_chain_t *a_chain)
{
dap_chain_net_t *l_net = a_chain ? dap_chain_net_by_id(a_chain->net_id) : NULL;
- if ( l_net )
- return dap_strdup_printf("chain-gdb.%s.chain-%016"DAP_UINT64_FORMAT_X,l_net->pub.name, a_chain->id.uint64);
- return NULL;
+ return l_net
+ ? dap_strdup_printf("chain-gdb.%s.chain-%016"DAP_UINT64_FORMAT_X, l_net->pub.name, a_chain->id.uint64)
+ : NULL;
}
dap_chain_t *dap_chain_net_get_chain_by_chain_type(dap_chain_net_t *a_net, dap_chain_type_t a_datum_type);
diff --git a/modules/net/include/dap_chain_node.h b/modules/net/include/dap_chain_node.h
index 32aff217939d229457e426ffa7bc7f9e03ea7de3..0eba403cc227013d6e0851ef2eaac20a0a4ffbdb 100644
--- a/modules/net/include/dap_chain_node.h
+++ b/modules/net/include/dap_chain_node.h
@@ -151,8 +151,7 @@ dap_chain_node_info_t* dap_chain_node_info_read(dap_chain_net_t * l_net, dap_cha
inline static char* dap_chain_node_addr_to_hash_str(dap_chain_node_addr_t *address)
{
- char *a_key = dap_hash_fast_str_new((const uint8_t*) address, sizeof(dap_chain_node_addr_t));
- return a_key;
+ return dap_hash_fast_str_new((const uint8_t*) address, sizeof(dap_chain_node_addr_t));
}
bool dap_chain_node_mempool_need_process(dap_chain_t *a_chain, dap_chain_datum_t *a_datum);
diff --git a/modules/net/srv/dap_chain_net_srv_order.c b/modules/net/srv/dap_chain_net_srv_order.c
index f817e0470f9992f02a4dbc5c7e2aead070c9d84b..332a1dd85d1e2611330fdea2b5961748ed46d564 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -519,21 +519,18 @@ void dap_chain_net_srv_order_dump_to_string(dap_chain_net_srv_order_t *a_order,d
{
if (a_order && a_str_out ){
dap_chain_hash_fast_t l_hash;
- char *l_hash_str;//[DAP_CHAIN_HASH_FAST_SIZE * 2 + 4];
dap_hash_fast(a_order, dap_chain_net_srv_order_get_size(a_order), &l_hash);
- //dap_chain_hash_fast_to_str(&l_hash,l_hash_str,sizeof(l_hash_str)-1);
- if(!dap_strcmp(a_hash_out_type,"hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_hash);
+ char *l_hash_str = dap_strcmp(a_hash_out_type,"hex")
+ ? dap_enc_base58_encode_hash_to_str(&l_hash)
+ : dap_chain_hash_fast_to_str_new(&l_hash);
dap_string_append_printf(a_str_out, "== Order %s ==\n", l_hash_str);
dap_string_append_printf(a_str_out, " version: %u\n", a_order->version );
switch ( a_order->direction) {
- case SERV_DIR_UNDEFINED: dap_string_append_printf(a_str_out, " direction: SERV_DIR_UNDEFINED\n" ); break;
- case SERV_DIR_SELL: dap_string_append_printf(a_str_out, " direction: SERV_DIR_SELL\n" ); break;
- case SERV_DIR_BUY: dap_string_append_printf(a_str_out, " direction: SERV_DIR_BUY\n" ); break;
+ case SERV_DIR_UNDEFINED: dap_string_append_printf(a_str_out, " direction: SERV_DIR_UNDEFINED\n" ); break;
+ case SERV_DIR_SELL: dap_string_append_printf(a_str_out, " direction: SERV_DIR_SELL\n" ); break;
+ case SERV_DIR_BUY: dap_string_append_printf(a_str_out, " direction: SERV_DIR_BUY\n" ); break;
}
dap_string_append_printf(a_str_out, " srv_uid: 0x%016"DAP_UINT64_FORMAT_X"\n", a_order->srv_uid.uint64 );
@@ -556,16 +553,15 @@ void dap_chain_net_srv_order_dump_to_string(dap_chain_net_srv_order_t *a_order,d
DAP_DELETE(l_region);
DAP_DELETE(l_hash_str);
- if(!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&a_order->tx_cond_hash);
- else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&a_order->tx_cond_hash);
- //dap_chain_hash_fast_to_str(&a_order->tx_cond_hash,l_hash_str, sizeof(l_hash_str)-1);
+ l_hash_str = dap_strcmp(a_hash_out_type, "hex")
+ ? dap_enc_base58_encode_hash_to_str(&a_order->tx_cond_hash)
+ : dap_chain_hash_fast_to_str_new(&a_order->tx_cond_hash);
dap_string_append_printf(a_str_out, " tx_cond_hash: %s\n", l_hash_str );
char *l_ext_out = a_order->ext_size ? DAP_NEW_Z_SIZE(char, a_order->ext_size * 2 + 1) : NULL;
- dap_bin2hex(l_ext_out, a_order->ext_n_sign, a_order->ext_size);
- if(l_ext_out)
+ if(l_ext_out) {
+ dap_bin2hex(l_ext_out, a_order->ext_n_sign, a_order->ext_size);
dap_string_append_printf(a_str_out, " ext: 0x%s\n", l_ext_out);
+ }
else
dap_string_append_printf(a_str_out, " ext: 0x0\n");
// order state
diff --git a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
index d7d576969a9452716cca98e295586330cb4fe7c7..15838d6281754c4eccd9e1c993781c3edcc9739e 100644
--- a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
+++ b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
@@ -552,7 +552,7 @@ static enum error_code s_cli_take(int a_argc, char **a_argv, int a_arg_index, da
}
size_t l_owner_pkey_size;
- uint8_t *l_owner_pkey = dap_enc_key_serealize_pub_key(l_owner_key, &l_owner_pkey_size);
+ uint8_t *l_owner_pkey = dap_enc_key_serialize_pub_key(l_owner_key, &l_owner_pkey_size);
dap_sign_t *l_owner_sign = NULL;
dap_chain_tx_sig_t *l_tx_sign = (dap_chain_tx_sig_t *)dap_chain_datum_tx_item_get(
l_cond_tx, NULL, TX_ITEM_TYPE_SIG, NULL);
diff --git a/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
index e55baf732e32860ca04738848294f20b3186102f..99185b9c4cd11030178d7ef19effc6320c40fd99 100644
--- a/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
@@ -1094,8 +1094,9 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
static void s_srv_stake_print(dap_chain_net_srv_stake_item_t *a_stake, dap_string_t *a_string)
{
- char *l_tx_hash_str = dap_chain_hash_fast_to_str_new(&a_stake->tx_hash);
- char *l_pkey_hash_str = dap_chain_hash_fast_to_str_new(&a_stake->signing_addr.data.hash_fast);
+ char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE], l_pkey_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&a_stake->tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
+ dap_chain_hash_fast_to_str(&a_stake->signing_addr.data.hash_fast, l_pkey_hash_str, sizeof(l_pkey_hash_str));
char *l_balance = dap_chain_balance_to_coins(a_stake->value);
dap_string_append_printf(a_string, "Pkey hash: %s\n"
"\tStake value: %s\n"
@@ -1103,8 +1104,6 @@ static void s_srv_stake_print(dap_chain_net_srv_stake_item_t *a_stake, dap_strin
"\tNode addr: "NODE_ADDR_FP_STR"\n\n",
l_pkey_hash_str, l_balance, l_tx_hash_str, NODE_ADDR_FP_ARGS_S(a_stake->node_addr));
DAP_DELETE(l_balance);
- DAP_DELETE(l_tx_hash_str);
- DAP_DELETE(l_pkey_hash_str);
}
/**
@@ -1599,12 +1598,10 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
dap_chain_datum_tx_t *l_datum_tx = NULL;
dap_chain_tx_out_cond_t *l_tx_out_cond = NULL;
int l_out_idx_tmp = 0;
- char *l_hash_str = NULL;
char *spaces = {"--------------------------------------------------------------------------------------------------------------------"};
char *l_signing_addr_str = NULL;
char *l_balance = NULL;
char *l_coins = NULL;
- char *l_pkey_hash_str = NULL;
char* l_node_address_text_block = NULL;
dap_chain_net_get_tx_all(l_net,TX_SEARCH_TYPE_NET,s_get_tx_filter_callback, l_args);
l_args->ret = dap_list_sort(l_args->ret, callback_compare_tx_list);
@@ -1616,16 +1613,17 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
dap_hash_fast(l_datum_tx, dap_chain_datum_tx_get_size(l_datum_tx), &l_datum_hash);
l_tx_out_cond = dap_chain_datum_tx_out_cond_get(l_datum_tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE,
&l_out_idx_tmp);
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_datum_hash);
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_datum_hash, l_hash_str, sizeof(l_hash_str));
dap_string_append_printf(l_str_tmp,"%s \n",spaces);
dap_string_append_printf(l_str_tmp,"%s \n",dap_ctime_r(&l_ts_create, buf));
dap_string_append_printf(l_str_tmp,"tx_hash:\t%s \n",l_hash_str);
l_signing_addr_str = dap_chain_addr_to_str(&l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr);
- l_pkey_hash_str = dap_chain_hash_fast_to_str_new(&l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr.data.hash_fast);
+ char l_pkey_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr.data.hash_fast, l_pkey_hash_str, sizeof(l_pkey_hash_str));
l_coins = dap_chain_balance_to_coins(l_tx_out_cond->header.value);
l_balance = dap_chain_balance_print(l_tx_out_cond->header.value);
- char *l_pkey_hash_str = dap_chain_hash_fast_to_str_new(&l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr.data.hash_fast);
dap_string_append_printf(l_str_tmp,"signing_addr:\t%s \n",l_signing_addr_str);
dap_string_append_printf(l_str_tmp,"signing_hash:\t%s \n",l_pkey_hash_str);
@@ -1635,9 +1633,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
DAP_DELETE(l_node_address_text_block);
DAP_DELETE(l_signing_addr_str);
- DAP_DELETE(l_pkey_hash_str);
DAP_DELETE(l_balance);
- DAP_DELETE(l_hash_str);
DAP_DEL_Z(l_coins);
}
@@ -1763,9 +1759,9 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
DAP_DELETE(l_decree_hash_str);
DAP_DELETE(l_tx);
} else {
- char *l_final_tx_hash_str = dap_chain_hash_fast_to_str_new(l_final_tx_hash);
+ char l_final_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(l_final_tx_hash, l_final_tx_hash_str, sizeof(l_final_tx_hash_str));
dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't invalidate transaction %s, examine log files for details", l_final_tx_hash_str);
- DAP_DELETE(l_final_tx_hash_str);
DAP_DELETE(l_tx);
return -21;
}
@@ -1788,9 +1784,9 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
DAP_DELETE(l_decree);
DAP_DELETE(l_decree_hash_str);
} else {
- char *l_final_tx_hash_str = dap_chain_hash_fast_to_str_new(l_final_tx_hash);
+ char l_final_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(l_final_tx_hash, l_final_tx_hash_str, sizeof(l_final_tx_hash_str));
dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't invalidate transaction %s, examine log files for details", l_final_tx_hash_str);
- DAP_DELETE(l_final_tx_hash_str);
DAP_DELETE(l_decree);
return -21;
}
@@ -1939,10 +1935,10 @@ static void s_cache_data(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
return;
dap_chain_net_srv_stake_cache_data_t l_cache_data;
dap_hash_fast(a_tx, dap_chain_datum_tx_get_size(a_tx), &l_cache_data.tx_hash);
+ char l_data_key[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_cache_data.tx_hash, l_data_key, sizeof(l_data_key));
l_cache_data.signing_addr = *a_signing_addr;
- char *l_data_key = dap_chain_hash_fast_to_str_new(&l_cache_data.tx_hash);
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_NET_SRV_STAKE_POS_DELEGATE_GDB_GROUP);
if (dap_global_db_set(l_gdb_group, l_data_key, &l_cache_data, sizeof(l_cache_data), true, NULL, NULL))
log_it(L_WARNING, "Stake service cache mismatch");
- DAP_DELETE(l_data_key);
}
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index e7613c3465e7735f16b0377bef031e0723359ae5..e70ab763c9b24ffe3344cf40a81bd467aafb375d 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -299,7 +299,7 @@ static dap_chain_hash_fast_t* dap_chain_net_vpn_client_tx_cond_hash(dap_chain_ne
l_cert = l_certs[0];
if(l_cert) {
size_t l_pub_key_data_size = 0;
- uint8_t *l_pub_key_data = dap_enc_key_serealize_pub_key(l_cert->enc_key, &l_pub_key_data_size);
+ uint8_t *l_pub_key_data = dap_enc_key_serialize_pub_key(l_cert->enc_key, &l_pub_key_data_size);
// save pub key
if(l_pub_key_data && l_pub_key_data_size > 0){
if(dap_global_db_gr_set(dap_strdup("client_pkey"), l_pub_key_data, l_pub_key_data_size,
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 7b7794b01d853475119c010dc865553a622f1217..2b6b5d437bf2761b3ebff034cc56eb0f3bba04bc 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -313,14 +313,15 @@ static int s_cli_parse_cmd_hash(char ** a_argv, int a_arg_index, int a_argc, cha
*/
static void s_cli_meta_hash_print( dap_string_t * a_str_tmp, const char * a_meta_title, dap_chain_block_meta_t * a_meta)
{
- if(a_meta->hdr.data_size == sizeof (dap_chain_hash_fast_t) ){
- char * l_hash_str = dap_chain_hash_fast_to_str_new( (dap_chain_hash_fast_t *) a_meta->data);
+ if (a_meta->hdr.data_size == sizeof (dap_chain_hash_fast_t)) {
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str((dap_chain_hash_fast_t*)a_meta->data, l_hash_str, sizeof(l_hash_str));
dap_string_append_printf(a_str_tmp,"\t\tPREV: \"%s\": %s\n", a_meta_title,l_hash_str);
- DAP_DELETE(l_hash_str);
- }else{
- char * l_data_hex = DAP_NEW_Z_SIZE(char,a_meta->hdr.data_size*2+3);
+ } else {
+ char *l_data_hex = DAP_NEW_Z_SIZE(char,a_meta->hdr.data_size * 2 + 3);
dap_bin2hex(l_data_hex, a_meta->data, a_meta->hdr.data_size);
- dap_string_append_printf(a_str_tmp,"\t\t\%s: 0x%s\n", a_meta_title, l_data_hex );
+ dap_string_append_printf(a_str_tmp,"\t\t\%s: 0x%s\n", a_meta_title, l_data_hex);
+ DAP_DELETE(l_data_hex);
}
}
@@ -332,9 +333,10 @@ static void s_cli_meta_hash_print( dap_string_t * a_str_tmp, const char * a_met
*/
static void s_cli_meta_hex_print( dap_string_t * a_str_tmp, const char * a_meta_title, dap_chain_block_meta_t * a_meta)
{
- char * l_data_hex = DAP_NEW_Z_SIZE(char,a_meta->hdr.data_size*2+3);
+ char *l_data_hex = DAP_NEW_Z_SIZE(char, a_meta->hdr.data_size * 2 + 3);
dap_bin2hex(l_data_hex, a_meta->data, a_meta->hdr.data_size);
- dap_string_append_printf(a_str_tmp,"\t\t\%s: 0x%s\n", a_meta_title, l_data_hex );
+ dap_string_append_printf(a_str_tmp,"\t\t\%s: 0x%s\n", a_meta_title, l_data_hex);
+ DAP_DELETE(l_data_hex);
}
/**
@@ -453,9 +455,8 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
&l_datum_size, NULL, NULL);
l_datums[0] = l_datum;
for (size_t i = 0; i < l_datums_count; i++) {
- dap_chain_hash_fast_t l_datum_hash = { };
- dap_hash_fast(l_datums[i]->data,l_datums[i]->header.data_size,&l_datum_hash);
- char *l_datums_datum_hash_str = dap_chain_hash_fast_to_str_new(&l_datum_hash);
+ char *l_datums_datum_hash_str;
+ dap_get_data_hash_str_static(l_datums[i]->data, l_datums[i]->header.data_size, l_datums_datum_hash_str);
bool l_err = dap_chain_node_mempool_process(l_chain, l_datums[i]);
if (l_err) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! Datum %s doesn't pass verifications, examine node log files",
@@ -466,11 +467,11 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
l_datums_datum_hash_str);
ret = 0;
}
- DAP_DELETE(l_datums_datum_hash_str);
if (l_err)
break;
}
dap_cli_server_cmd_set_reply_text(a_str_reply, "All datums processed");
+ DAP_DELETE(l_gdb_group_mempool);
} break;
case SUBCMD_NEW_COMPLETE:{
@@ -555,20 +556,19 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
}
// Signatures
dap_string_append_printf(l_str_tmp,"\t\tsignatures:\tcount: %zu\n",l_block_cache->sign_count );
- for (uint32_t i=0; i < l_block_cache->sign_count ; i++){
- //dap_sign_t * l_sign =l_block_cache->sign[i];
+ for (uint32_t i=0; i < l_block_cache->sign_count ; i++) {
dap_sign_t * l_sign = dap_chain_block_sign_get(l_block_cache->block, l_block_cache->block_size, i);
size_t l_sign_size = dap_sign_get_size(l_sign);
dap_chain_addr_t l_addr = {0};
dap_chain_hash_fast_t l_pkey_hash;
dap_sign_get_pkey_hash(l_sign, &l_pkey_hash);
dap_chain_addr_fill(&l_addr, l_sign->header.type, &l_pkey_hash, l_net->pub.id);
- char * l_pkey_hash_str = dap_chain_hash_fast_to_str_new(&l_pkey_hash);
- char * l_addr_str = dap_chain_addr_to_str(&l_addr);
+ char l_pkey_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_pkey_hash, l_pkey_hash_str, sizeof(l_pkey_hash_str));
+ char *l_addr_str = dap_chain_addr_to_str(&l_addr);
dap_string_append_printf(l_str_tmp,"\t\t\ttype:%s size: %zd pkey_hash: %s \n"
"\t\t\t\taddr: %s \n", dap_sign_type_to_str( l_sign->header.type ),
l_sign_size, l_pkey_hash_str, l_addr_str );
- DAP_DELETE( l_pkey_hash_str );
}
dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_tmp->str);
dap_string_free(l_str_tmp, true);
@@ -1165,6 +1165,9 @@ static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain,
l_atom_iter->chain = a_chain;
l_atom_iter->cell_id = a_cell_id;
l_atom_iter->with_treshold = a_with_treshold;
+#ifdef WIN32
+ log_it(L_DEBUG, "! %p create caller id %lu", l_atom_iter, GetThreadId(GetCurrentThread()));
+#endif
return l_atom_iter;
}
@@ -1205,8 +1208,8 @@ static dap_chain_atom_ptr_t s_callback_atom_iter_find_by_hash(dap_chain_atom_ite
{
assert(a_atom_iter);
dap_chain_cs_blocks_pvt_t *l_blocks_pvt = PVT(DAP_CHAIN_CS_BLOCKS(a_atom_iter->chain));
- pthread_rwlock_rdlock(&l_blocks_pvt->rwlock);
dap_chain_block_cache_t * l_block_cache = NULL;
+ pthread_rwlock_rdlock(&l_blocks_pvt->rwlock);
HASH_FIND(hh, l_blocks_pvt->blocks, a_atom_hash, sizeof(*a_atom_hash), l_block_cache);
pthread_rwlock_unlock(&l_blocks_pvt->rwlock);
a_atom_iter->cur_item = l_block_cache;
@@ -1405,8 +1408,11 @@ static dap_chain_atom_ptr_t *s_callback_atom_iter_get_lasts( dap_chain_atom_iter
* @brief s_callback_atom_iter_delete
* @param a_atom_iter
*/
-static void s_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter )
+static void s_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter)
{
+#ifdef WIN32
+ log_it(L_DEBUG, "! %p delete caller id %lu", a_atom_iter, GetThreadId(GetCurrentThread()));
+#endif
DAP_DELETE(a_atom_iter);
}
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index d29b0958c3755fb2fe1e9b545dc025c9c894dea1..f6280ad2f36a96e3efb661912db0658c70459725 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -62,7 +62,7 @@ typedef struct dap_chain_cs_dag_event_item {
dap_nanotime_t ts_added;
dap_chain_cs_dag_event_t *event;
size_t event_size;
- UT_hash_handle hh;
+ UT_hash_handle hh, th;
} dap_chain_cs_dag_event_item_t;
typedef struct dap_chain_cs_dag_blocked {
@@ -184,8 +184,7 @@ static void s_history_callback_round_notify(dap_global_db_context_t *a_context,
dap_chain_net_t *l_net = dap_chain_net_by_id(l_dag->chain->net_id);
debug_if(s_debug_more, L_DEBUG, "%s.%s: op_code='%c' group=\"%s\" key=\"%s\" value_size=%zu",
l_net->pub.name, l_dag->chain->name, a_obj->type, a_obj->group, a_obj->key, a_obj->value_len);
- if (a_obj->type == DAP_DB$K_OPTYPE_ADD &&
- l_dag->callback_cs_event_round_sync) {
+ if (a_obj->type == DAP_DB$K_OPTYPE_ADD && l_dag->callback_cs_event_round_sync) {
if (!l_dag->broadcast_disable)
dap_chain_cs_dag_event_broadcast(l_dag, a_obj, a_context);
if (dap_strcmp(a_obj->key, DAG_ROUND_CURRENT_KEY)) // check key for round increment, if no than process event
@@ -295,24 +294,17 @@ int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
l_dag->is_celled = dap_config_get_item_bool_default(a_chain_cfg,"dag","is_celled",false);
l_dag->is_add_directly = dap_config_get_item_bool_default(a_chain_cfg,"dag","is_add_directly",false);
l_dag->datum_add_hashes_count = dap_config_get_item_uint16_default(a_chain_cfg,"dag","datum_add_hashes_count",1);
- char * l_round_new_str = dap_strdup( dap_config_get_item_str_default(a_chain_cfg,"dag","gdb_group_events_round_new", "new"));
dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
-
l_dag->broadcast_disable = true;
- char *l_gdb_group;
- if (!l_dag->is_celled)
- l_gdb_group = dap_strdup_printf( "dag-%s-%s-round", l_net->pub.gdb_groups_prefix, a_chain->name);
- else {
- uint64_t l_cell_id = 0; //a_chain->cells->id.uint64;
- l_gdb_group = dap_strdup_printf( "dag-%s-%s-%016"DAP_UINT64_FORMAT_x"-round", l_net->pub.gdb_groups_prefix, a_chain->name, l_cell_id);
- }
- l_dag->gdb_group_events_round_new = dap_strdup_printf("%s.%s", l_gdb_group, l_round_new_str);
+ char *l_gdb_group = dap_strdup_printf(l_dag->is_celled ? "dag-%s-%s-%016llx-round" : "dag-%s-%s-round",
+ l_net->pub.gdb_groups_prefix, a_chain->name, 0LLU);
+ l_dag->gdb_group_events_round_new = dap_strdup_printf("%s.%s", l_gdb_group,
+ dap_config_get_item_str_default(a_chain_cfg,"dag","gdb_group_events_round_new", "new"));
DAP_DELETE(l_gdb_group);
- DAP_DELETE(l_round_new_str);
dap_global_db_add_sync_extra_group(l_net->pub.name, l_dag->gdb_group_events_round_new, s_history_callback_round_notify, l_dag);
l_dag->broadcast_disable = false;
byte_t *l_current_round = dap_global_db_get_sync(l_dag->gdb_group_events_round_new, DAG_ROUND_CURRENT_KEY, NULL, NULL, NULL);
- l_dag->round_current = l_current_round ? *(uint64_t *)l_current_round : 0;
+ l_dag->round_current = l_current_round ? *(uint64_t*)l_current_round : 0;
DAP_DELETE(l_current_round);
dap_global_db_get_all_raw(l_dag->gdb_group_events_round_new, 0, 0, s_dag_rounds_events_iter, l_dag);
PVT(l_dag)->mempool_timer = dap_interval_timer_create(15000, s_timer_process_callback, a_chain);
@@ -512,6 +504,8 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
switch (ret) {
case ATOM_ACCEPT:
ret = s_chain_callback_atom_verify(a_chain, a_atom, a_atom_size);
+ if (ret == ATOM_MOVE_TO_THRESHOLD)
+ ret = ATOM_REJECT; /* TODO: A temporary fix for memory consumption */
if(s_debug_more)
log_it(L_DEBUG, "Verified atom %p: %s", a_atom, ret == ATOM_ACCEPT ? "accepted" :
(ret == ATOM_REJECT ? "rejected" : "thresholded"));
@@ -613,121 +607,120 @@ static size_t s_callback_add_datums(dap_chain_t *a_chain, dap_chain_datum_t **a_
{
size_t l_datum_processed = 0;
for (size_t i = 0; i < a_datums_count; i++) {
- size_t l_datum_size = dap_chain_datum_size(a_datums[i]);
- dap_chain_datum_t *l_datum = (dap_chain_datum_t *)a_datums[i];
+ dap_chain_datum_t *l_datum = *(a_datums + i);
+ size_t l_datum_size = dap_chain_datum_size(l_datum);
if (!l_datum_size || !l_datum)
continue;
-
if (s_chain_callback_datums_pool_proc(a_chain, l_datum))
- l_datum_processed++;
+ ++l_datum_processed;
}
return l_datum_processed;
-
}
-static bool s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain_datum_t *a_datum)
-{
- if (!a_datum || !a_chain) {
+static bool s_chain_callback_datums_pool_proc(dap_chain_t *a_chain, dap_chain_datum_t *a_datum) {
+ if (!a_datum || !a_chain)
log_it(L_ERROR, "Datum or chain in mempool processing comes NULL");
- return false;
- }
+
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG(a_chain);
- // Prepare hashes
- size_t l_hashes_size = l_dag->datum_add_hashes_count;
- if (l_dag->is_single_line ) // If single line - only one link inside
- l_hashes_size = 1;
- dap_chain_hash_fast_t * l_hashes = l_hashes_size ? DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,
- sizeof(dap_chain_hash_fast_t) * l_hashes_size) : NULL;
- size_t l_hashes_linked = 0;
- dap_chain_cell_t *l_cell = NULL;
- // Prepare round
- if (l_hashes_size & !s_seed_mode) {
- pthread_rwlock_rdlock(&PVT(l_dag)->events_rwlock);
- size_t l_rnd_steps = 0;
- // Linking events randomly with ones from previous round
- do {
- dap_chain_cs_dag_event_item_t *l_event_ext_item = NULL;
- int l_unlinked_size = HASH_COUNT(PVT(l_dag)->events_lasts_unlinked);
- if (!l_unlinked_size)
+ /* If datum passes thru rounds, let's check if it wasn't added before */
+ dap_chain_hash_fast_t l_datum_hash;
+ dap_hash_fast(a_datum, dap_chain_datum_size(a_datum), &l_datum_hash);
+ if (!l_dag->is_add_directly) {
+ bool l_dup_found = false;
+ size_t l_objs_count = 0;
+ dap_global_db_obj_t * l_objs = dap_global_db_get_all_sync(l_dag->gdb_group_events_round_new, &l_objs_count);
+ for (size_t i = 0; i < l_objs_count; ++i) {
+ dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t*)l_objs[i].value;
+ if (!memcmp(&l_datum_hash, &(l_round_item->round_info.datum_hash), sizeof(dap_chain_hash_fast_t))) {
+ l_dup_found = true;
break;
- int l_index = rand() % l_unlinked_size;
- l_event_ext_item = PVT(l_dag)->events_lasts_unlinked;
- for (int i = 0; i < l_index; i++) {
- l_event_ext_item = l_event_ext_item->hh.next;
}
- dap_chain_hash_fast_t *l_hash = &l_event_ext_item->hash;
+ }
+ dap_global_db_objs_delete(l_objs, l_objs_count);
+ if (l_dup_found) {
+ char l_datum_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_datum_hash, l_datum_hash_str, sizeof(l_datum_hash_str));
+ log_it(L_ERROR, "Datum %s was already added to round, drop it", l_datum_hash_str);
+ return false;
+ }
+ }
+
+ size_t l_hashes_size = l_dag->is_single_line ? 1 : l_dag->datum_add_hashes_count,
+ l_hashes_linked = 0;
+ dap_chain_hash_fast_t *l_hashes = l_hashes_size && !s_seed_mode
+ ? DAP_NEW_STACK_SIZE(dap_chain_hash_fast_t, l_hashes_size * sizeof(dap_chain_hash_fast_t))
+ : NULL;
- bool l_is_already_in_event = false;
- for (uint16_t i = 0; i < l_hashes_linked; i++) { // check if we already added it
- if (l_hashes && memcmp(&l_hashes[i], l_hash, sizeof(*l_hash)) ==0) {
- l_is_already_in_event = true;
+ /* Prepare round */
+ if (l_hashes && l_hashes_size) {
+ pthread_rwlock_rdlock(&PVT(l_dag)->events_rwlock);
+ if (!HASH_COUNT(PVT(l_dag)->events_lasts_unlinked)) {
+ pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
+ log_it(L_INFO, "Nothing to link");
+ return false;
+ }
+ /* We'll use modification-safe iteration thru the additional hashtable thus the chosen events will not repeat */
+#define always_true(ev) ({ (void*)ev, true; })
+ dap_chain_cs_dag_event_item_t *l_tmp = NULL, *l_cur_ev, *l_tmp_ev;
+ HASH_SELECT(th, l_tmp, hh, PVT(l_dag)->events_lasts_unlinked, always_true); /* Always true predicate */
+ pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
+ while ((l_hashes_linked < l_hashes_size) && (HASH_CNT(th, l_tmp) > 0)) {
+ int l_random_id = rand() % HASH_CNT(th, l_tmp), l_hash_id = 0;
+ HASH_ITER(th, l_tmp, l_cur_ev, l_tmp_ev) {
+ if (l_hash_id++ == l_random_id) {
+ l_hashes[l_hashes_linked++] = l_cur_ev->hash;
+ HASH_DEL(l_tmp, l_cur_ev);
break;
}
}
- if (!l_is_already_in_event && l_hashes_linked < l_hashes_size) {
- l_hashes[l_hashes_linked++] = *l_hash;
- }
-
- l_rnd_steps++;
- if (l_rnd_steps > 100) // Too many attempts
- break;
- } while (l_hashes_linked < l_hashes_size);
- pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
- // Check if we have enought hash links
+ }
+ HASH_CLEAR(th, l_tmp);
if (l_hashes_linked < l_hashes_size) {
- log_it(L_ERROR, "Can't link new events randomly for 100 attempts");
+ log_it(L_ERROR, "No enough unlinked events present (only %lu of %lu), a dummy round?", l_hashes_linked, l_hashes_size);
return false;
}
}
- if (l_hashes_linked || s_seed_mode ) {
- dap_chain_cs_dag_event_t * l_event = NULL;
- size_t l_event_size = 0;
- byte_t *l_current_round = dap_global_db_get_sync(l_dag->gdb_group_events_round_new, DAG_ROUND_CURRENT_KEY, NULL, NULL, NULL);
- l_dag->round_current = l_current_round ? *(uint64_t *)l_current_round : 0;
- DAP_DELETE(l_current_round);
- if (l_dag->round_current < l_dag->round_completed)
- l_dag->round_current = l_dag->round_completed;
- uint64_t l_round_current = ++l_dag->round_current;
- if (l_dag->callback_cs_event_create)
- l_event = l_dag->callback_cs_event_create(l_dag, a_datum, l_hashes, l_hashes_linked, &l_event_size);
- DAP_DELETE(l_hashes);
- if (l_event && l_event_size) { // Event is created
- if (l_dag->is_add_directly) {
- l_cell = a_chain->cells;
- if (s_chain_callback_atom_add(a_chain, l_event, l_event_size) == ATOM_ACCEPT) {
- if (dap_chain_atom_save(a_chain, (uint8_t *)l_event, l_event_size, a_chain->cells->id) < 0)
- log_it(L_ERROR, "Can't add new event to the file");
- return true;
- } else {
- log_it(L_ERROR, "Can't add new event");
- return false;
- }
- } else { // add to new round into global_db
- dap_global_db_set(l_dag->gdb_group_events_round_new, DAG_ROUND_CURRENT_KEY,
- &l_round_current, sizeof(uint64_t), false, NULL, NULL);
- dap_chain_hash_fast_t l_event_hash, l_datum_hash;
- dap_chain_cs_dag_event_round_item_t *l_round_item =
- DAP_NEW_Z_SIZE(dap_chain_cs_dag_event_round_item_t,
- sizeof(dap_chain_cs_dag_event_round_item_t));
- dap_hash_fast(a_datum, dap_chain_datum_size(a_datum), &l_datum_hash);
- l_round_item->round_info.datum_hash = l_datum_hash;
- dap_chain_cs_dag_event_calc_hash(l_event,l_event_size, &l_event_hash);
- char * l_event_hash_str = dap_chain_hash_fast_to_str_new(&l_event_hash);
- bool l_res = dap_chain_cs_dag_event_gdb_set(l_dag, l_event_hash_str, l_event, l_event_size, l_round_item);
- DAP_DELETE(l_round_item);
- if (l_res)
- log_it(L_INFO, "Event %s placed in the new forming round", l_event_hash_str);
- else
- log_it(L_ERROR,"Can't add new event to the new events round");
- DAP_DEL_Z(l_event_hash_str);
- return l_res;
- }
- } else {
- log_it(L_ERROR,"Can't create new event!");
+
+ /*
+ * Either we're in seed mode ==> the new event will be not linked to anything
+ * or we have successfully chosen the hash(es) to link with.
+ * No additional conditions required.
+ */
+ byte_t *l_current_round = dap_global_db_get_sync(DAG_ROUND_CURRENT_KEY, l_dag->gdb_group_events_round_new, NULL, NULL, NULL);
+ uint64_t l_round_current = MAX(l_current_round ? *(uint64_t*)l_current_round : 0, l_dag->round_completed);
+ DAP_DELETE(l_current_round);
+ l_dag->round_current = ++l_round_current; /* it's an atomic_store */
+ uint64_t l_event_size = 0;
+ dap_chain_cs_dag_event_t * l_event = l_dag->callback_cs_event_create
+ ? l_dag->callback_cs_event_create(l_dag, a_datum, l_hashes, l_hashes_linked, &l_event_size)
+ : NULL;
+ if (!l_event || !l_event_size) {
+ log_it(L_ERROR,"Can't create new event!");
+ return false;
+ }
+
+ if (l_dag->is_add_directly) {
+ dap_chain_atom_verify_res_t l_verify_res;
+ switch (l_verify_res = s_chain_callback_atom_add(a_chain, l_event, l_event_size)) {
+ case ATOM_ACCEPT:
+ return dap_chain_atom_save(a_chain, (uint8_t *)l_event, l_event_size, a_chain->cells->id) > 0;
+ default:
+ log_it(L_ERROR, "Can't add new event to the file, atom verification result %d", l_verify_res);
return false;
}
}
- return false;
+
+ dap_global_db_set(l_dag->gdb_group_events_round_new, DAG_ROUND_CURRENT_KEY,
+ &l_round_current, sizeof(uint64_t), false, NULL, NULL);
+ dap_chain_cs_dag_event_round_item_t l_round_item = { .round_info.datum_hash = l_datum_hash };
+ char *l_event_hash_str;
+ dap_get_data_hash_str_static(l_event, l_event_size, l_event_hash_str);
+ bool l_res = dap_chain_cs_dag_event_gdb_set(l_dag, l_event_hash_str, l_event, l_event_size, &l_round_item);
+ log_it(l_res ? L_INFO : L_ERROR,
+ l_res ? "Event %s placed in the new forming round"
+ : "Can't add new event [%s] to the new events round",
+ l_event_hash_str);
+ return l_res;
}
@@ -825,15 +818,13 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_
dap_chain_hash_fast_t l_event_hash;
dap_chain_cs_dag_event_calc_hash(l_event,a_atom_size, &l_event_hash);
if ( memcmp( &l_event_hash, &l_dag->static_genesis_event_hash, sizeof(l_event_hash) ) != 0 ){
- char * l_event_hash_str = dap_chain_hash_fast_to_str_new(&l_event_hash);
- char * l_genesis_event_hash_str = dap_chain_hash_fast_to_str_new(&l_dag->static_genesis_event_hash);
+ char l_event_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE], l_genesis_event_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(&l_event_hash, l_event_hash_str, sizeof(l_event_hash_str));
+ dap_chain_hash_fast_to_str(&l_dag->static_genesis_event_hash, l_genesis_event_hash_str, sizeof(l_genesis_event_hash_str));
log_it(L_WARNING, "Wrong genesis event %s (staticly predefined %s)",l_event_hash_str, l_genesis_event_hash_str);
- DAP_DELETE(l_event_hash_str);
- DAP_DELETE(l_genesis_event_hash_str);
return ATOM_REJECT;
} else {
- if (s_debug_more)
- log_it(L_INFO, "Accepting static genesis event");
+ debug_if(s_debug_more, L_INFO, "Accepting static genesis event");
return ATOM_ACCEPT;
}
}
@@ -851,11 +842,12 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_
pthread_rwlock_rdlock(l_events_rwlock);
HASH_FIND(hh, PVT(l_dag)->events ,l_hash ,sizeof (*l_hash), l_event_search);
pthread_rwlock_unlock(l_events_rwlock);
- if ( l_event_search == NULL ){
- char * l_hash_str = dap_chain_hash_fast_to_str_new(l_hash);
- if(s_debug_more)
+ if (l_event_search == NULL) {
+ if(s_debug_more) {
+ char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
+ dap_chain_hash_fast_to_str(l_hash, l_hash_str, sizeof(l_hash_str));
log_it(L_WARNING, "Hash %s wasn't in hashtable of previously parsed", l_hash_str);
- DAP_DELETE(l_hash_str);
+ }
res = ATOM_MOVE_TO_THRESHOLD;
break;
}
@@ -1051,7 +1043,7 @@ static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_c
l_atom_iter->with_treshold = a_with_treshold;
pthread_rwlock_rdlock(&a_chain->atoms_rwlock);
#ifdef WIN32
- log_it(L_DEBUG, "! Create caller id %lu", GetThreadId(GetCurrentThread()));
+ log_it(L_DEBUG, "! %p create caller id %lu", l_atom_iter, GetThreadId(GetCurrentThread()));
#endif
return l_atom_iter;
}
@@ -1063,20 +1055,20 @@ static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_c
* @param a_datums_count
* @return
*/
-static dap_chain_datum_t** s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t a_event, size_t a_atom_size, size_t *a_datums_count)
+static dap_chain_datum_t **s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t a_event, size_t a_atom_size, size_t *a_datums_count)
{
assert(a_datums_count);
- if(a_event){
- dap_chain_datum_t * l_datum = dap_chain_cs_dag_event_get_datum((dap_chain_cs_dag_event_t*) a_event, a_atom_size);
- if (l_datum){
- dap_chain_datum_t ** l_datums = DAP_NEW_SIZE(dap_chain_datum_t*, sizeof(dap_chain_datum_t*));
- *a_datums_count = 1;
- l_datums[0] = l_datum;
- return l_datums;
- }else
- return NULL;
- }else
+ if (!a_event)
return NULL;
+ dap_chain_datum_t *l_datum = dap_chain_cs_dag_event_get_datum((dap_chain_cs_dag_event_t*)a_event, a_atom_size);
+ if (!l_datum)
+ return NULL;
+
+ dap_chain_datum_t **l_datums = DAP_NEW_Z(dap_chain_datum_t*);
+ if (a_datums_count)
+ *a_datums_count = 1;
+ l_datums[0] = l_datum;
+ return l_datums;
}
/**
@@ -1199,7 +1191,7 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_links( dap_chain_ato
char * l_link_hash_str = dap_chain_hash_fast_to_str_new(l_link_hash);
char * l_event_hash_str = l_event_item ? dap_chain_hash_fast_to_str_new(&l_event_item->hash) : NULL;
log_it(L_ERROR,"Can't find %s->%s links", l_event_hash_str ? l_event_hash_str : "[null]", l_link_hash_str);
- DAP_DELETE(l_event_hash_str);
+ DAP_DEL_Z(l_event_hash_str);
DAP_DELETE(l_link_hash_str);
(*a_links_size_array)--;
}
@@ -1416,8 +1408,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
// If not verify only mode we add
if ( ! l_verify_only ){
dap_chain_atom_ptr_t l_new_atom = DAP_DUP_SIZE(l_event, l_event_size); // produce deep copy of event;
- memcpy((void *)l_new_atom, l_event, l_event_size);
- if(s_chain_callback_atom_add(l_chain, l_new_atom,l_event_size) < 0) { // Add new atom in chain
+ if(s_chain_callback_atom_add(l_chain, l_new_atom, l_event_size) < 0) { // Add new atom in chain
DAP_DELETE(l_new_atom);
dap_string_append_printf(l_str_ret_tmp, "Event %s not added in chain\n", l_objs[i].key);
} else {
@@ -1452,9 +1443,8 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
// Spread new mempool changes and dag events in network - going to SYNC_ALL
// dap_chain_net_sync_all(l_net);
}
- }else if ( l_event_cmd_str ) {
- char *l_datum_hash_hex_str = NULL;
- char *l_datum_hash_base58_str = NULL;
+ } else if (l_event_cmd_str) {
+ char *l_datum_hash_hex_str = NULL, *l_datum_hash_base58_str = NULL;
if ( strcmp( l_event_cmd_str, "create" ) == 0 ) {
dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
@@ -1488,8 +1478,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
l_event_subcmd = SUBCMD_UNDEFINED;
}
- char *l_event_hash_hex_str = NULL;
- char *l_event_hash_base58_str = NULL;
+ char *l_event_hash_hex_str = NULL, *l_event_hash_base58_str = NULL;
// datum hash may be in hex or base58 format
if(l_event_hash_str) {
if(!dap_strncmp(l_event_hash_str, "0x", 2) || !dap_strncmp(l_event_hash_str, "0X", 2)) {
@@ -1503,114 +1492,100 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
}
if (l_event_hash_hex_str)
- dap_chain_hash_fast_from_str(l_event_hash_hex_str,&l_event_hash);
-
- switch ( l_event_subcmd ){
- case SUBCMD_EVENT_CREATE:{
- size_t l_datums_count=1;
- char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
- dap_chain_datum_t ** l_datums = DAP_NEW_Z_SIZE(dap_chain_datum_t*,
- sizeof(dap_chain_datum_t*)*l_datums_count);
- size_t l_datum_size = 0;
- dap_chain_datum_t * l_datum = (dap_chain_datum_t*) dap_global_db_get_sync(l_gdb_group_mempool, l_datum_hash_hex_str ,
- &l_datum_size, NULL, NULL );
- l_datums[0] = l_datum;
- if ( s_callback_add_datums(l_chain, l_datums, l_datums_count) == l_datums_count ){
- for ( size_t i = 0; i <l_datums_count; i++){
- dap_chain_hash_fast_t l_datum_hash;
- dap_hash_fast(l_datums[i]->data,l_datums[i]->header.data_size, &l_datum_hash);
- char * l_datums_datum_hash_str = dap_chain_hash_fast_to_str_new(&l_datum_hash);
- if ( dap_global_db_del_sync(l_gdb_group_mempool, l_datums_datum_hash_str ) ==0 ){
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Converted datum %s from mempool to event in the new forming round ",
- l_datums_datum_hash_str);
- DAP_DELETE(l_datums_datum_hash_str);
- ret = 0;
- }else {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Warning! Can't delete datum %s from mempool after conversion to event in the new forming round ",
- l_datums_datum_hash_str);
- ret = 1;
- }
- }
- }else {
- if(!dap_strcmp(l_hash_out_type,"hex")){
+ dap_chain_hash_fast_from_str(l_event_hash_hex_str, &l_event_hash);
+
+ switch (l_event_subcmd) {
+
+ case SUBCMD_EVENT_CREATE: {
+ char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
+ size_t l_datum_size = 0;
+ dap_chain_datum_t *l_datum = (dap_chain_datum_t*)
+ dap_global_db_get_sync(l_datum_hash_hex_str,l_gdb_group_mempool, &l_datum_size, NULL, NULL);
+ if (s_callback_add_datums(l_chain, &l_datum, 1)) {
+ char *l_datums_datum_hash_str;
+ dap_get_data_hash_str_static(l_datum->data, l_datum->header.data_size, l_datums_datum_hash_str);
+ if (dap_global_db_del_sync(l_datum_hash_str, l_gdb_group_mempool)) {
dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Warning! Can't convert datum %s from mempool to event in the new forming round ", l_datum_hash_hex_str);
- }
- else {
+ "Converted datum %s from mempool to event in the new forming round ",
+ l_datum_hash_str);
+ ret = 0;
+ } else {
dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Warning! Can't convert datum %s from mempool to event in the new forming round ", l_datum_hash_base58_str);
+ "Warning! Can't delete datum %s from mempool after conversion to event in the new forming round ",
+ l_datum_hash_str);
+ ret = 1;
}
+ } else {
+ if (!dap_strcmp(l_hash_out_type, "hex")) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "Warning! Can't convert datum %s from mempool to event in the new forming round ", l_datum_hash_hex_str);
+ } else {
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "Warning! Can't convert datum %s from mempool to event in the new forming round ", l_datum_hash_base58_str);
+
ret = -12;
+ }
+ }
+ DAP_DELETE(l_gdb_group_mempool);
+ // dap_chain_net_sync_all(l_net);
+ } break; /* SUBCMD_EVENT_CREATE */
+ case SUBCMD_EVENT_CANCEL: {
+ char *l_gdb_group_events = DAP_CHAIN_CS_DAG(l_chain)->gdb_group_events_round_new;
+ if (dap_global_db_del_sync(l_gdb_group_events, l_event_hash_hex_str) == 0) {
+ if(!dap_strcmp(l_hash_out_type, "hex")) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "Successfuly removed event %s from the new forming round ",
+ l_event_hash_hex_str);
+ } else {
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "Successfuly removed event %s from the new forming round ",
+ l_event_hash_base58_str);
}
- DAP_DELETE(l_gdb_group_mempool);
- DAP_DELETE(l_datum_hash_hex_str);
- DAP_DELETE(l_datum_hash_base58_str);
- // dap_chain_net_sync_all(l_net);
- }break;
- case SUBCMD_EVENT_CANCEL:{
- char * l_gdb_group_events = DAP_CHAIN_CS_DAG(l_chain)->gdb_group_events_round_new;
- if ( dap_global_db_del_sync(l_gdb_group_events, l_event_hash_hex_str ) ==0){
- if(!dap_strcmp(l_hash_out_type, "hex")){
+ ret = 0;
+ } else {
+ dap_chain_cs_dag_event_item_t * l_event_item = NULL;
+ pthread_rwlock_rdlock(&PVT(l_dag)->events_rwlock);
+ HASH_FIND(hh,PVT(l_dag)->events,&l_event_hash,sizeof(l_event_hash),l_event_item);
+ pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
+ if (l_event_item) {
+ pthread_rwlock_wrlock(&PVT(l_dag)->events_rwlock);
+ HASH_DELETE(hh, PVT(l_dag)->events, l_event_item);
+ pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
+ if(!dap_strcmp(l_hash_out_type, "hex")) {
+ log_it(L_WARNING, "Dropped event %s from chains! Hope you know what are you doing!",
+ l_event_hash_hex_str);
dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Successfuly removed event %s from the new forming round ",
- l_event_hash_hex_str);
- }
- else{
+ "Dropped event 0x%s from chains! Hope you know what are you doing! ",
+ l_event_hash_hex_str);
+ } else {
+ log_it(L_WARNING, "Dropped event %s from chains! Hope you know what are you doing!",
+ l_event_hash_base58_str);
dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Successfuly removed event %s from the new forming round ",
- l_event_hash_base58_str);
+ "Dropped event 0x%s from chains! Hope you know what are you doing! ",
+ l_event_hash_base58_str);
}
- ret = 0;
- }else {
- dap_chain_cs_dag_event_item_t * l_event_item = NULL;
- pthread_rwlock_rdlock(&PVT(l_dag)->events_rwlock);
- HASH_FIND(hh,PVT(l_dag)->events,&l_event_hash,sizeof(l_event_hash),l_event_item);
- pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
- if ( l_event_item ){
- pthread_rwlock_wrlock(&PVT(l_dag)->events_rwlock);
- HASH_DELETE(hh, PVT(l_dag)->events, l_event_item);
- pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
- if(!dap_strcmp(l_hash_out_type, "hex")) {
- log_it(L_WARNING, "Dropped event %s from chains! Hope you know what are you doing!",
- l_event_hash_hex_str);
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Dropped event 0x%s from chains! Hope you know what are you doing! ",
- l_event_hash_hex_str);
- }
- else {
- log_it(L_WARNING, "Dropped event %s from chains! Hope you know what are you doing!",
- l_event_hash_base58_str);
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Dropped event 0x%s from chains! Hope you know what are you doing! ",
- l_event_hash_base58_str);
- }
- dap_chain_save_all(l_chain);
- }else {
- if(!dap_strcmp(l_hash_out_type, "hex")) {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't remove event 0x%s ",
- l_event_hash_hex_str);
- }
- else {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't remove event 0x%s ",
- l_event_hash_base58_str);
- }
- ret = -1;
+ dap_chain_save_all(l_chain);
+ } else {
+ if(!dap_strcmp(l_hash_out_type, "hex")) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "Can't remove event 0x%s ",
+ l_event_hash_hex_str);
+ } else {
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "Can't remove event 0x%s ",
+ l_event_hash_base58_str);
}
+ ret = -1;
}
- DAP_DELETE(l_event_hash_hex_str);
- DAP_DELETE(l_event_hash_base58_str);
- // dap_chain_net_sync_gdb(l_net);
- }break;
- case SUBCMD_EVENT_DUMP: {
- dap_chain_cs_dag_event_round_item_t * l_round_item = NULL;
- dap_chain_cs_dag_event_t * l_event = NULL;
- // dap_chain_cs_dag_event_round_info_t l_event_round_info;
- size_t l_event_size = 0;
+ }
+ // dap_chain_net_sync_gdb(l_net);
+ } break; /* SUBCMD_EVENT_CANCEL */
+
+ case SUBCMD_EVENT_DUMP: {
+ dap_chain_cs_dag_event_round_item_t *l_round_item = NULL;
+ dap_chain_cs_dag_event_t *l_event = NULL;
+ size_t l_event_size = 0;
if (l_from_events_str && strcmp(l_from_events_str,"round.new") == 0) {
const char * l_gdb_group_events = l_dag->gdb_group_events_round_new;
size_t l_round_item_size = 0;
@@ -1753,7 +1728,8 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
}
DAP_DELETE(l_round_item);
} break;
- case SUBCMD_EVENT_LIST:{
+
+ case SUBCMD_EVENT_LIST: {
if (l_from_events_str && strcmp(l_from_events_str,"round.new") == 0) {
char * l_gdb_group_events = DAP_CHAIN_CS_DAG(l_chain)->gdb_group_events_round_new;
dap_string_t * l_str_tmp = dap_string_new("");
@@ -1825,7 +1801,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
ret=-14;
}
- }break;
+ } break;
case SUBCMD_EVENT_SIGN: { // Sign event command
char * l_gdb_group_events = l_dag->gdb_group_events_round_new;
size_t l_round_item_size = 0;
@@ -1888,7 +1864,11 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
ret=-11;
}
}
- }else {
+ DAP_DEL_Z(l_datum_hash_hex_str);
+ DAP_DEL_Z(l_datum_hash_base58_str);
+ DAP_DEL_Z(l_event_hash_hex_str);
+ DAP_DEL_Z(l_event_hash_base58_str);
+ } else {
dap_cli_server_cmd_set_reply_text(a_str_reply,
"Undefined subcommand");
ret = -13;
diff --git a/modules/type/dag/dap_chain_cs_dag_event.c b/modules/type/dag/dap_chain_cs_dag_event.c
index e8609e97b19614c53216ea6ee26bc710ac072ff4..cddbc4bdd5ef1dfdb11605e3d4e3b72647481902 100644
--- a/modules/type/dag/dap_chain_cs_dag_event.c
+++ b/modules/type/dag/dap_chain_cs_dag_event.c
@@ -105,7 +105,7 @@ size_t dap_chain_cs_dag_event_sign_add(dap_chain_cs_dag_event_t **a_event_ptr, s
// check for re-sign with same key
if (dap_chain_cs_dag_event_sign_exists(l_event, a_event_size, a_key)) {
size_t l_pub_key_size = 0;
- uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_key, &l_pub_key_size);
+ uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_size);
dap_hash_fast_t l_pkey_hash = {};
dap_hash_fast(l_pub_key, l_pub_key_size, &l_pkey_hash);
DAP_DEL_Z(l_pub_key);
@@ -128,7 +128,7 @@ size_t dap_chain_cs_dag_event_sign_add(dap_chain_cs_dag_event_t **a_event_ptr, s
static bool s_sign_exists(uint8_t *a_pos, size_t a_len, dap_enc_key_t *a_key)
{
size_t l_pub_key_size = 0;
- uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_key, &l_pub_key_size);
+ uint8_t *l_pub_key = dap_enc_key_serialize_pub_key(a_key, &l_pub_key_size);
uint8_t *l_offset = a_pos;
while (l_offset < a_pos + a_len) {
dap_sign_t * l_item_sign = (dap_sign_t *)l_offset;
diff --git a/modules/type/dag/include/dap_chain_cs_dag_event.h b/modules/type/dag/include/dap_chain_cs_dag_event.h
index 4a1785773ec8261f60efb196b3b92844ed5e415b..388508dccb0630a039d4289adad542bd5acbaca6 100644
--- a/modules/type/dag/include/dap_chain_cs_dag_event.h
+++ b/modules/type/dag/include/dap_chain_cs_dag_event.h
@@ -78,19 +78,18 @@ dap_chain_cs_dag_event_t *dap_chain_cs_dag_event_new(dap_chain_id_t a_chain_id,
*/
static inline dap_chain_datum_t* dap_chain_cs_dag_event_get_datum(dap_chain_cs_dag_event_t * a_event,size_t a_event_size)
{
- return a_event->header.hash_count*sizeof(dap_chain_hash_fast_t)<=a_event_size?(dap_chain_datum_t* ) (a_event->hashes_n_datum_n_signs
- +a_event->header.hash_count*sizeof(dap_chain_hash_fast_t)): NULL;
+ return a_event->header.hash_count * sizeof(dap_chain_hash_fast_t) <= a_event_size
+ ? (dap_chain_datum_t*)(a_event->hashes_n_datum_n_signs + a_event->header.hash_count * sizeof(dap_chain_hash_fast_t))
+ : NULL;
}
static inline size_t dap_chain_cs_dag_event_get_datum_size_maximum(dap_chain_cs_dag_event_t * a_event,size_t a_event_size)
{
- return a_event->header.hash_count*sizeof(dap_chain_hash_fast_t)<=a_event_size ?
- a_event_size - a_event->header.hash_count*sizeof(dap_chain_hash_fast_t): 0;
+ return a_event->header.hash_count * sizeof(dap_chain_hash_fast_t) <= a_event_size
+ ? a_event_size - a_event->header.hash_count * sizeof(dap_chain_hash_fast_t)
+ : 0;
}
-dap_chain_cs_dag_event_t * dap_chain_cs_dag_event_copy(dap_chain_cs_dag_event_t *a_event_src, size_t a_event_size);
-
-// Important: returns new deep copy of event
// dap_chain_cs_dag_event_t * dap_chain_cs_dag_event_sign_add( dap_chain_cs_dag_event_t * a_event, size_t a_event_size,
// size_t * a_event_size_new,
// dap_chain_net_t * a_net, dap_enc_key_t * a_key);