diff --git a/dap-sdk b/dap-sdk
index 84afcccb3f8de976ba0029801844421406ff83a7..e19cc10d05f66dff8611d11b7b9482093ccf01c1 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 84afcccb3f8de976ba0029801844421406ff83a7
+Subproject commit e19cc10d05f66dff8611d11b7b9482093ccf01c1
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index 3b4d5491912e457cbeeddb4182d136f810cddb04..eb9355737fc50227ea4ce0022a9e85be324fbf6e 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -517,6 +517,13 @@ static bool s_load_notify_callback(dap_chain_t* a_chain) {
return true;
}
+static int s_ids_sort(const void *a_cell_id1, const void *a_cell_id2)
+{
+ uint64_t a = ((dap_chain_cell_id_t *)a_cell_id1)->uint64,
+ b = ((dap_chain_cell_id_t *)a_cell_id2)->uint64;
+ return a > b ? 1 : (a < b ? -1 : 0);
+}
+
/**
* @brief dap_chain_load_all
* @param l_chain
@@ -536,36 +543,61 @@ int dap_chain_load_all(dap_chain_t *a_chain)
DIR *l_dir = opendir(l_storage_dir);
dap_return_val_if_fail_err(l_dir, -3, "Cannot open directory %s, error %d: \"%s\"",
DAP_CHAIN_PVT(a_chain)->file_storage_dir, errno, dap_strerror(errno));
- int l_err = -1;
- const char l_suffix[] = ".dchaincell", *l_filename;
+ int l_err = 0, l_cell_idx = 0;
+ const char l_suffix[] = "." DAP_CHAIN_CELL_FILE_EXT, *l_filename;
struct dirent *l_dir_entry = NULL;
- dap_time_t l_ts_start = dap_time_now();
+ dap_chain_cell_id_t l_cell_ids[DAP_CHAIN_CELL_MAX_COUNT];
while (( l_dir_entry = readdir(l_dir) ) ) {
l_filename = l_dir_entry->d_name;
size_t l_namelen = strlen(l_filename);
- if ( l_namelen >= sizeof(l_suffix) && !strncmp(l_filename + l_namelen - (sizeof(l_suffix) - 1), l_suffix, sizeof(l_suffix) - 1) ) {
- dap_timerfd_t* l_load_notify_timer = dap_timerfd_start(5000, (dap_timerfd_callback_t)s_load_notify_callback, a_chain);
- l_err = dap_chain_cell_open(a_chain, l_filename, 'a');
- dap_timerfd_delete(l_load_notify_timer->worker, l_load_notify_timer->esocket_uuid);
- if (l_err)
+ if (l_namelen >= sizeof(l_suffix)) {
+ /* Check filename */
+ char l_fmt[32] = "", l_ext[ sizeof(DAP_CHAIN_CELL_FILE_EXT) ] = "", l_ext2 = '\0';
+ snprintf(l_fmt, sizeof(l_fmt), "%s%lu%s", "%"DAP_UINT64_FORMAT_x".%", sizeof(DAP_CHAIN_CELL_FILE_EXT) - 1, "[^.].%c");
+ switch ( sscanf(l_filename, l_fmt, &l_cell_ids[l_cell_idx].uint64, l_ext, &l_ext2) ) {
+ case 3:
+ // TODO: X.dchaincell.*, just ignore for now
break;
- s_load_notify_callback(a_chain);
+ case 2:
+ if ( !dap_strncmp(l_ext, DAP_CHAIN_CELL_FILE_EXT, sizeof(l_ext)) ) {
+ l_cell_idx++;
+ break;
+ }
+ default:
+ log_it(L_ERROR, "Invalid cell file name \"%s\"", l_filename);
+ l_err = EINVAL;
+ break;
+ }
}
}
closedir(l_dir);
-
- switch (l_err) {
- case 0:
- log_it(L_INFO, "Loaded all chain \"%s : %s\" cells in %lf s",
- a_chain->net_name, a_chain->name, difftime((time_t)dap_time_now(), l_ts_start));
- break;
- case -1:
- if (!( l_err = dap_chain_cell_open(a_chain, "0.dchaincell", 'w') ))
+
+ if (!l_cell_idx) {
+ if (!l_err)
+ l_err = dap_chain_cell_open(a_chain, c_dap_chain_cell_id_null, 'w');
+ if (l_err)
+ log_it(L_ERROR, "Chain \"%s : %s\" was not loaded, error %d", a_chain->net_name, a_chain->name, l_err);
+ else
log_it(L_INFO, "Initialized chain \"%s : %s\" cell 0", a_chain->net_name, a_chain->name);
- break;
- default:
- log_it(L_ERROR, "Chain \"%s : %s\" cell was not loaded, error %d", a_chain->net_name, a_chain->name, l_err);
+ return l_err;
}
+
+ qsort(l_cell_ids, l_cell_idx, sizeof(dap_chain_cell_id_t), s_ids_sort);
+
+ dap_time_t l_ts_start = dap_time_now();
+ for (int i = 0; i < l_cell_idx; i++) {
+ dap_timerfd_t* l_load_notify_timer = dap_timerfd_start(5000, (dap_timerfd_callback_t)s_load_notify_callback, a_chain);
+ l_err = dap_chain_cell_open(a_chain, l_cell_ids[i], 'a');
+ dap_timerfd_delete(l_load_notify_timer->worker, l_load_notify_timer->esocket_uuid);
+ if (l_err) {
+ log_it(L_ERROR, "Chain \"%s : %s\" cell 0x%016" DAP_UINT64_FORMAT_x " was not loaded, error %d",
+ a_chain->net_name, a_chain->name, (uint64_t)l_cell_idx, l_err);
+ return l_err;
+ }
+ s_load_notify_callback(a_chain);
+ }
+ log_it(L_INFO, "Loaded all chain \"%s : %s\" cells in %lf s",
+ a_chain->net_name, a_chain->name, difftime((time_t)dap_time_now(), l_ts_start));
return l_err;
}
@@ -960,4 +992,4 @@ const char *dap_chain_type_to_str(const dap_chain_type_t a_default_chain_type)
default:
return "unknown";
}
-}
\ No newline at end of file
+}
diff --git a/modules/chain/dap_chain_cell.c b/modules/chain/dap_chain_cell.c
index f2b61e19c87a90aa421d540220e4f931654ed30c..18bac156b3189207edf3e1ec36f7669f6914fc31 100644
--- a/modules/chain/dap_chain_cell.c
+++ b/modules/chain/dap_chain_cell.c
@@ -43,8 +43,6 @@
#define DAP_CHAIN_CELL_FILE_TYPE_COMPRESSED 1
#define DAP_MAPPED_VOLUME_LIMIT ( 1 << 28 ) // 256 MB for now, may be should be configurable?
-#define CELL_FILE_EXT "dchaincell"
-
/**
* @struct dap_chain_cell_file_header
*/
@@ -451,33 +449,9 @@ DAP_STATIC_INLINE int s_cell_open(dap_chain_t *a_chain, const char *a_filepath,
#undef m_ret_err
}
-int dap_chain_cell_open(dap_chain_t *a_chain, const char *a_filename, const char a_mode) {
- dap_chain_cell_id_t l_cell_id = { };
- { /* Check filename */
- char l_fmt[32] = "", l_ext[ sizeof(CELL_FILE_EXT) ] = "", l_ext2 = '\0';
- snprintf(l_fmt, sizeof(l_fmt), "%s%lu%s", "%"DAP_UINT64_FORMAT_x".%", sizeof(CELL_FILE_EXT) - 1, "[^.].%c");
-
- switch ( sscanf(a_filename, l_fmt, &l_cell_id.uint64, l_ext, &l_ext2) ) {
- case 3:
- // TODO: X.dchaincell.*
- case 2:
- if ( !dap_strncmp(l_ext, CELL_FILE_EXT, sizeof(l_ext)) )
- break;
- default:
- return log_it(L_ERROR, "Invalid cell file name \"%s\"", a_filename), EINVAL;
- }
- }
- char l_full_path[MAX_PATH];
- snprintf(l_full_path, MAX_PATH, "%s/%s", DAP_CHAIN_PVT(a_chain)->file_storage_dir, a_filename);
- pthread_rwlock_wrlock(&a_chain->cell_rwlock);
- int l_ret = s_cell_open(a_chain, l_full_path, l_cell_id, a_mode);
- pthread_rwlock_unlock(&a_chain->cell_rwlock);
- return l_ret;
-}
-
-int dap_chain_cell_open_by_id(dap_chain_t *a_chain, const dap_chain_cell_id_t a_cell_id, const char a_mode) {
+int dap_chain_cell_open(dap_chain_t *a_chain, const dap_chain_cell_id_t a_cell_id, const char a_mode) {
char l_full_path[MAX_PATH];
- snprintf(l_full_path, MAX_PATH, "%s/%"DAP_UINT64_FORMAT_x"."CELL_FILE_EXT, DAP_CHAIN_PVT(a_chain)->file_storage_dir, a_cell_id.uint64);
+ snprintf(l_full_path, MAX_PATH, "%s/%"DAP_UINT64_FORMAT_x"."DAP_CHAIN_CELL_FILE_EXT, DAP_CHAIN_PVT(a_chain)->file_storage_dir, a_cell_id.uint64);
pthread_rwlock_wrlock(&a_chain->cell_rwlock);
int l_ret = s_cell_open(a_chain, l_full_path, a_cell_id, a_mode);
pthread_rwlock_unlock(&a_chain->cell_rwlock);
diff --git a/modules/chain/dap_chain_ch.c b/modules/chain/dap_chain_ch.c
index b4d8e0bff82d80cc473a037eccea210bb8dec6de..47fd9aec71e4b07cb53464382fb84441cd23efd1 100644
--- a/modules/chain/dap_chain_ch.c
+++ b/modules/chain/dap_chain_ch.c
@@ -345,8 +345,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
} break;
case DAP_CHAIN_CH_PKT_TYPE_CHAIN: {
- if (!l_chain_pkt_data_size || l_chain_pkt_data_size > sizeof(dap_chain_ch_pkt_t) + DAP_CHAIN_ATOM_MAX_SIZE
- * 5) { // For legacy block sizes
+ if (!l_chain_pkt_data_size || l_chain_pkt_data_size > sizeof(dap_chain_ch_pkt_t) + DAP_CHAIN_ATOM_MAX_SIZE) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
diff --git a/modules/chain/include/dap_chain_cell.h b/modules/chain/include/dap_chain_cell.h
index 658a8b90e2ddcd1e4d755218317b5582ec153f2a..54e34fa2d8a3998c1a6708c3ec6971f74ba21320 100644
--- a/modules/chain/include/dap_chain_cell.h
+++ b/modules/chain/include/dap_chain_cell.h
@@ -29,6 +29,9 @@
#include "dap_chain.h"
#include "dap_chain_common.h"
+#define DAP_CHAIN_CELL_MAX_COUNT 32
+#define DAP_CHAIN_CELL_FILE_EXT "dchaincell"
+
typedef struct dap_chain_cell_mmap_data dap_chain_cell_mmap_data_t;
typedef struct dap_chain_cell {
@@ -76,10 +79,9 @@ typedef struct dap_chain_cell_decl{
int dap_chain_cell_init(void);
-int dap_chain_cell_open(dap_chain_t *a_chain, const char *a_filename, const char a_mode);
-int dap_chain_cell_open_by_id(dap_chain_t *a_chain, const dap_chain_cell_id_t a_cell_id, const char a_mode);
+int dap_chain_cell_open(dap_chain_t *a_chain, const dap_chain_cell_id_t a_cell_id, const char a_mode);
DAP_STATIC_INLINE int dap_chain_cell_create(dap_chain_t *a_chain, const dap_chain_cell_id_t a_cell_id) {
- return dap_chain_cell_open_by_id(a_chain, a_cell_id, 'w');
+ return dap_chain_cell_open(a_chain, a_cell_id, 'w');
}
DAP_INLINE dap_chain_cell_t *dap_chain_cell_find_by_id(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id) {
diff --git a/modules/chain/include/dap_chain_srv.h b/modules/chain/include/dap_chain_srv.h
index e20369d54858a73f045daa5c30937f615fd2ccdf..2a8b6fd293629e38e42830043ac3a000e75a3ab3 100644
--- a/modules/chain/include/dap_chain_srv.h
+++ b/modules/chain/include/dap_chain_srv.h
@@ -31,7 +31,7 @@ along with any CellFrame SDK based project. If not, see <http://www.gnu.org/lic
// System services literlas
#define DAP_CHAIN_SRV_STAKE_POS_DELEGATE_LITERAL "PoS-delegate"
#define DAP_CHAIN_SRV_XCHANGE_LITERAL "eXchange"
-#define DAP_CHAIN_SRV_VOTING_LITERAL "voting"
+#define DAP_CHAIN_SRV_VOTING_LITERAL "poll"
// Start service callback
typedef void * (*dap_chain_srv_callback_start_t)(dap_chain_net_id_t a_net_id, dap_config_t *a_config);
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 0d548a8f5ed63784b4763803922eaf2011690956..9bce084c74a62ebb77d0c6dca9c2e799a8557bef 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -908,7 +908,7 @@ static dap_list_t *s_get_validators_list(dap_chain_esbocs_t *a_esbocs, dap_hash_
dap_chain_esbocs_pvt_t *l_esbocs_pvt = PVT(a_esbocs);
dap_list_t *l_ret = NULL;
dap_list_t *l_validators = NULL;
- if (!l_esbocs_pvt->poa_mode) {
+ if (l_esbocs_pvt->poa_mode) { // UNDO it after debug
if (a_excluded_list_size) {
l_validators = dap_chain_net_srv_stake_get_validators(a_esbocs->chain->net_id, false, NULL);
uint16_t l_excluded_num = *a_excluded_list;
@@ -2248,7 +2248,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void *a_arg)
dap_chain_esbocs_message_t *l_message = (dap_chain_esbocs_message_t *)l_ch_pkt->data;
size_t l_message_size = l_ch_pkt->hdr.data_size;
if (l_message_size < sizeof(dap_chain_esbocs_message_t) ||
- l_message_size > DAP_CHAIN_ATOM_MAX_SIZE + PKT_SIGN_N_HDR_OVERHEAD ||
+ l_message_size > DAP_CHAIN_CANDIDATE_MAX_SIZE + PKT_SIGN_N_HDR_OVERHEAD ||
l_message_size != sizeof(*l_message) + l_message->hdr.sign_size + l_message->hdr.message_size) {
log_it(L_WARNING, "Invalid message size %zu, drop this packet", l_message_size);
return false;
diff --git a/modules/ledger/dap_chain_ledger_anchor.c b/modules/ledger/dap_chain_ledger_anchor.c
index 56e073d0b4007e8546cb3402cbe6df8bc3ab4bcb..62732c28119305c94efc7b6b3a18ad84323c4da9 100644
--- a/modules/ledger/dap_chain_ledger_anchor.c
+++ b/modules/ledger/dap_chain_ledger_anchor.c
@@ -212,6 +212,8 @@ int dap_ledger_anchor_purge(dap_ledger_t *a_ledger, dap_chain_id_t a_chain_id)
if (l_decree) {
l_decree->is_applied = l_decree->wait_for_apply = false;
l_decree->anchor_hash = (dap_hash_fast_t) { };
+ if (l_decree->decree->header.sub_type == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_REWARD)
+ dap_chain_net_remove_last_reward(a_ledger->net);
} else
log_it(L_ERROR, "Corrupted datum anchor, can't get decree by hash %s", dap_hash_fast_to_str_static(&l_decree_hash));
} else
diff --git a/modules/ledger/dap_chain_ledger_tx.c b/modules/ledger/dap_chain_ledger_tx.c
index bdfbb6d2d2a9514da12c858998ac16f7f70b6bc4..7b27491501e0713be1c13d736bda1998a51dc092 100644
--- a/modules/ledger/dap_chain_ledger_tx.c
+++ b/modules/ledger/dap_chain_ledger_tx.c
@@ -266,6 +266,10 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
return DAP_LEDGER_TX_CHECK_FOR_REMOVING_CANT_FIND_TX;
}
}
+
+ if (a_ledger->is_hardfork_state)
+ return DAP_LEDGER_CHECK_OK;
+
/*
* Steps of checking for current transaction tx2 and every previous transaction tx1:
* 1. valid(tx2.dap_chain_datum_tx_sig.pkey)
@@ -294,7 +298,7 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
int l_prev_tx_count = 0;
// 1. Verify signature in current transaction
- if (!a_from_threshold && !a_ledger->is_hardfork_state && dap_chain_datum_tx_verify_sign(a_tx, 0))
+ if (!a_from_threshold && dap_chain_datum_tx_verify_sign(a_tx, 0))
return DAP_LEDGER_CHECK_NOT_ENOUGH_VALID_SIGNS;
// ----------------------------------------------------------------
@@ -1228,6 +1232,15 @@ dap_list_t *s_trackers_aggregate(dap_ledger_t *a_ledger, dap_list_t *a_trackers,
return a_trackers;
}
+void s_trackers_clear(void *a_list_elm)
+{
+ struct tracker_mover *l_free = a_list_elm;
+ struct tracker_mover_item *it, *tmp;
+ DL_FOREACH_SAFE(l_free->items, it, tmp)
+ DAP_DELETE(it); // No need for DL_DELETE cause clear the full list
+ DAP_DELETE(a_list_elm);
+}
+
/**
* @brief Add new transaction to the cache list
* @param a_ledger
@@ -1247,14 +1260,19 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
dap_list_t *l_list_bound_items = NULL;
dap_list_t *l_list_tx_out = NULL;
char l_main_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX] = { '\0' };
-
+ dap_list_t *l_trackers_mover = NULL;
bool l_from_threshold = a_from_threshold;
dap_hash_fast_t l_tx_hash = *a_tx_hash;
byte_t *l_item = NULL;
size_t l_tx_item_size = 0;
if (a_ledger->is_hardfork_state) {
+ struct tracker_mover *l_hardfork_tracker = NULL;
TX_ITEM_ITER_TX(l_item, l_tx_item_size, a_tx) {
+ if (*l_item == TX_ITEM_TYPE_OUT_EXT || *l_item == TX_ITEM_TYPE_OUT_COND) {
+ l_list_tx_out = dap_list_append(l_list_tx_out, l_item);
+ continue;
+ }
if (*l_item != TX_ITEM_TYPE_TSD)
continue;
dap_tsd_t *l_tsd = (dap_tsd_t *)((dap_chain_tx_tsd_t *)l_item)->tsd;
@@ -1273,8 +1291,40 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
}
dap_strncpy(l_main_token_ticker, (char *)l_tsd->data, DAP_CHAIN_TICKER_SIZE_MAX);
} break;
+ case DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_VOTING_HASH: {
+ if (l_tsd->size != sizeof(dap_hash_fast_t)) {
+ log_it(L_WARNING, "Illegal harfork datum tx TSD VOTING_HASH size %u", l_tsd->size);
+ break;
+ }
+ l_hardfork_tracker = DAP_NEW_Z(struct tracker_mover);
+ if (!l_hardfork_tracker) {
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+ break;
+ }
+ l_hardfork_tracker->voting_hash = *(dap_hash_fast_t *)l_tsd->data;
+ l_trackers_mover = dap_list_append(l_trackers_mover, l_hardfork_tracker);
+ } break;
+ case DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_TRACKER: {
+ if (l_tsd->size != sizeof(dap_ledger_hardfork_tracker_t)) {
+ log_it(L_WARNING, "Illegal harfork datum tx TSD TRACKER size %u", l_tsd->size);
+ break;
+ }
+ if (!l_hardfork_tracker) {
+ log_it(L_WARNING, "No voting hash defined for tracking item");
+ break;
+ }
+ dap_ledger_hardfork_tracker_t *l_tsd_item = (dap_ledger_hardfork_tracker_t *)l_tsd->data;
+ struct tracker_mover_item *l_tracker_item = DAP_NEW_Z(struct tracker_mover_item);
+ if (!l_tracker_item) {
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+ break;
+ }
+ l_tracker_item->pkey_hash = l_tsd_item->pkey_hash;
+ l_tracker_item->coloured_value = l_tsd_item->coloured_value;
+ DL_APPEND(l_hardfork_tracker->items, l_tracker_item);
+ } break;
default:
- log_it(L_WARNING, "Illegal harfork datum tx TSD item type %d", l_tsd->type);
+ log_it(L_WARNING, "Illegal harfork datum tx TSD item type 0x%X", l_tsd->type);
break;
}
}
@@ -1315,7 +1365,6 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
// Mark 'out' items in cache if they were used & delete previous transactions from cache if it need
// find all bound pairs 'in' and 'out'
size_t l_outs_used = dap_list_length(l_list_bound_items);
- dap_list_t *l_trackers_mover = NULL;
dap_store_obj_t *l_cache_used_outs = NULL;
char *l_ledger_cache_group = NULL;
if ( is_ledger_cached(l_ledger_pvt) ) {
@@ -1521,6 +1570,8 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
pthread_rwlock_unlock(&s_verificators_rwlock);
if (l_verificator && l_verificator->callback_out_add)
l_verificator->callback_out_add(a_ledger, a_tx, &l_tx_hash, l_cond);
+ l_value = l_cond->header.value;
+ l_cur_token_ticker = l_main_token_ticker;
} break;
default:
log_it(L_ERROR, "Unknown item type %d", l_type);
@@ -1576,10 +1627,15 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
bool l_vote_add = false;
if (!l_voting_found && l_vote_tx_item && dap_hash_fast_compare(&l_mover->voting_hash, &l_vote_tx_item->voting_hash))
l_voting_found = l_vote_add = true;
- if (!dap_strcmp(l_cur_token_ticker, l_mover->ticker))
- continue;
- dap_ledger_tokenizer_t *l_moving_sum = s_tokenizer_find(l_values_from_cur_tx, l_mover->ticker);
- assert(l_moving_sum);
+ uint256_t l_moving_sum = {};
+ if (!a_ledger->is_hardfork_state) {
+ if (dap_strcmp(l_cur_token_ticker, l_mover->ticker))
+ continue;
+ dap_ledger_tokenizer_t *l_moving_sum_per_token = s_tokenizer_find(l_values_from_cur_tx, l_mover->ticker);
+ assert(l_moving_sum_per_token);
+ l_moving_sum = l_moving_sum_per_token->sum;
+ } else
+ l_moving_sum = l_value;
dap_ledger_tracker_t *l_tracker = NULL;
struct tracker_mover_item *it;
uint256_t l_moved_value = {};
@@ -1603,7 +1659,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
DL_APPEND(l_tracker->items, l_tracker_item);
uint256_t l_coloured_value;
MULT_256_256(l_value, it->coloured_value, &l_coloured_value);
- DIV_256(l_coloured_value, l_moving_sum->sum, &l_coloured_value);
+ DIV_256(l_coloured_value, l_moving_sum, &l_coloured_value);
if (compare256(it->cur_value, l_coloured_value) > 0 &&
!IS_ZERO_256(l_coloured_value)) {
SUBTRACT_256_256(it->cur_value, l_coloured_value, &it->cur_value);
@@ -1645,56 +1701,6 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
}
}
- if (a_ledger->is_hardfork_state) {
- TX_ITEM_ITER_TX(l_item, l_tx_item_size, a_tx) {
- if (*l_item != TX_ITEM_TYPE_TSD)
- continue;
- dap_tsd_t *l_tsd = (dap_tsd_t *)((dap_chain_tx_tsd_t *)l_item)->tsd;
- dap_ledger_tracker_t *l_tracker_current = NULL;
- switch (l_tsd->type) {
- case DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_VOTING_HASH: {
- if (l_tsd->size != sizeof(dap_hash_fast_t)) {
- log_it(L_WARNING, "Illegal harfork datum tx TSD VOTING_HASH size %u", l_tsd->size);
- break;
- }
- l_tracker_current = DAP_NEW_Z(dap_ledger_tracker_t);
- if (!l_tracker_current) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- break;
- }
- l_tracker_current->voting_hash = *(dap_hash_fast_t *)l_tsd->data;
- l_tx_item->out_metadata[0].trackers = dap_list_append(l_tx_item->out_metadata[0].trackers, l_tracker_current);
- } break;
- case DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_TRACKER: {
- if (l_tsd->size != sizeof(dap_ledger_hardfork_tracker_t)) {
- log_it(L_WARNING, "Illegal harfork datum tx TSD VOTING_HASH size %u", l_tsd->size);
- break;
- }
- if (!l_tracker_current) {
- log_it(L_WARNING, "No voting hash defined for tracking item");
- break;
- }
- dap_ledger_hardfork_tracker_t *l_tsd_item = (dap_ledger_hardfork_tracker_t *)l_tsd->data;
- dap_ledger_tracker_item_t *l_item = DAP_NEW_Z(dap_ledger_tracker_item_t);
- if (!l_tracker_current) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- break;
- }
- l_item->pkey_hash = l_tsd_item->pkey_hash;
- l_item->coloured_value = l_tsd_item->coloured_value;
- DL_APPEND(l_tracker_current->items, l_item);
- } break;
- default:
- log_it(L_WARNING, "Illegal harfork datum tx TSD item type 0x%X", l_tsd->type);
- break;
- }
- if (l_tsd->size != sizeof(dap_ledger_tracker_t)) {
- log_it(L_WARNING, "Incorrect size of TSD tracker section %u (need %zu)", l_tsd->size, sizeof(dap_ledger_tracker_t));
- break;
- }
- }
- }
-
// add transaction to the cache list
if (l_multichannel)
l_tx_item->cache_data.flags |= LEDGER_PVT_TX_META_FLAG_MULTICHANNEL;
@@ -1742,7 +1748,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
dap_ledger_pvt_threshold_txs_proc(a_ledger);
FIN:
if (l_trackers_mover)
- dap_list_free_full(l_trackers_mover, dap_ledger_colour_clear_callback);
+ dap_list_free_full(l_trackers_mover, s_trackers_clear);
if (l_list_bound_items)
dap_list_free_full(l_list_bound_items, NULL);
if (l_list_tx_out)
diff --git a/modules/net-srv/dap_chain_net_srv_order.c b/modules/net-srv/dap_chain_net_srv_order.c
index bc45709734eddfd4afc072f7ffae5c00b6a07f39..108748a8722a4f06fe7049f7d0c0e4c15ef96a6f 100644
--- a/modules/net-srv/dap_chain_net_srv_order.c
+++ b/modules/net-srv/dap_chain_net_srv_order.c
@@ -83,11 +83,12 @@ void dap_chain_net_srv_order_deinit()
}
-int dap_chain_srv_order_pin_init() {
+int dap_chain_srv_order_pin_init()
+{
dap_list_t *l_group_list = dap_global_db_driver_get_groups_by_mask("*.service.orders");
for (dap_list_t *l_list = l_group_list; l_list; l_list = dap_list_next(l_list)) {
size_t l_ret_count;
- dap_store_obj_t * l_ret = dap_global_db_get_all_raw_sync((char*)l_list->data, &l_ret_count);
+ dap_store_obj_t *l_ret = dap_global_db_get_all_raw_sync((char*)l_list->data, &l_ret_count);
if (!l_ret) {
dap_store_obj_free(l_ret, l_ret_count);
return -2;
@@ -98,6 +99,8 @@ int dap_chain_srv_order_pin_init() {
dap_stream_node_addr_t l_addr = dap_stream_node_addr_from_cert(l_cert);
const char * l_node_addr_str = dap_stream_node_addr_to_str_static(l_addr);
for(size_t i = 0; i < l_ret_count; i++) {
+ if (dap_store_obj_get_type(l_ret + i) != DAP_GLOBAL_DB_OPTYPE_ADD)
+ continue;
const dap_chain_net_srv_order_t *l_order = dap_chain_net_srv_order_check(l_ret[i].key, l_ret[i].value, l_ret[i].value_len);
if (!l_order)
continue;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 421600f3189bff46e5b1027102b157063252aa4a..6bc90cd871bbb0f836097bc7f9919d12061591f9 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -2817,7 +2817,9 @@ int dap_chain_net_add_reward(dap_chain_net_t *a_net, uint256_t a_reward, uint64_
void dap_chain_net_remove_last_reward(dap_chain_net_t *a_net)
{
- DL_DELETE(PVT(a_net)->rewards, PVT(a_net)->rewards);
+ struct block_reward *l_last_reward = PVT(a_net)->rewards;
+ DL_DELETE(PVT(a_net)->rewards, l_last_reward);
+ DAP_DELETE(l_last_reward);
}
uint256_t dap_chain_net_get_reward(dap_chain_net_t *a_net, uint64_t a_block_num)
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index e30de2009d83fc58abc93ebbf736d08f0da726b8..de5136367edb8c39e170f602c5999a8b706e59ba 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -492,7 +492,7 @@ dap_chain_datum_t **s_service_state_datums_create(dap_chain_srv_hardfork_state_t
{
dap_chain_datum_t **ret = NULL;
size_t l_datums_count = 0;
- const uint64_t l_max_step_size = DAP_CHAIN_ATOM_MAX_SIZE - sizeof(dap_chain_datum_service_state_t);
+ const uint64_t l_max_step_size = DAP_CHAIN_CANDIDATE_MAX_SIZE - sizeof(dap_chain_datum_service_state_t);
uint64_t l_step_size = dap_min(l_max_step_size, a_state->size);
byte_t *l_offset = a_state->data, *l_ptr = l_offset, *l_end = a_state->data + a_state->size * a_state->count;
while (l_offset < l_end) {
@@ -551,6 +551,27 @@ int dap_chain_node_hardfork_prepare(dap_chain_t *a_chain, dap_time_t a_last_bloc
return 0;
}
+static int s_tx_trackers_add(dap_chain_datum_tx_t **a_tx, dap_list_t *a_trackers)
+{
+ for (dap_list_t *it = a_trackers; it; it = it->next) {
+ dap_ledger_tracker_t *l_tracker = it->data;
+ dap_chain_tx_tsd_t *l_tracker_hash_tsd = dap_chain_datum_tx_item_tsd_create(&l_tracker->voting_hash, DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_VOTING_HASH, sizeof(dap_hash_fast_t));
+ if (!l_tracker_hash_tsd)
+ return -1;
+ if (dap_chain_datum_tx_add_item(a_tx, l_tracker_hash_tsd) != 1)
+ return -2;
+ for (dap_ledger_tracker_item_t *l_item = l_tracker->items; l_item; l_item = l_item->next) {
+ dap_ledger_hardfork_tracker_t l_hardfork_tracker = { .pkey_hash = l_item->pkey_hash, .coloured_value = l_item->coloured_value };
+ dap_chain_tx_tsd_t *l_tracker_tsd = dap_chain_datum_tx_item_tsd_create(&l_hardfork_tracker, DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_TRACKER, sizeof(dap_ledger_hardfork_tracker_t));
+ if (!l_tracker_tsd)
+ return -3;
+ if (dap_chain_datum_tx_add_item(a_tx, l_tracker_tsd) != 1)
+ return -4;
+ }
+ }
+ return 0;
+}
+
dap_chain_datum_t *s_datum_tx_create(dap_chain_addr_t *a_addr, const char *a_ticker, uint256_t a_value, dap_list_t *a_trackers)
{
dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
@@ -560,17 +581,9 @@ dap_chain_datum_t *s_datum_tx_create(dap_chain_addr_t *a_addr, const char *a_tic
dap_chain_datum_tx_delete(l_tx);
return NULL;
}
- for (dap_list_t *it = a_trackers; it; it = it->next) {
- dap_ledger_tracker_t *l_tracker = it->data;
- dap_chain_tx_tsd_t *l_tracker_tsd = dap_chain_datum_tx_item_tsd_create(l_tracker, DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_TRACKER, sizeof(dap_ledger_tracker_t));
- if (!l_tracker_tsd) {
- dap_chain_datum_tx_delete(l_tx);
- return NULL;
- }
- if (dap_chain_datum_tx_add_item(&l_tx, l_tracker_tsd) != 1) {
- dap_chain_datum_tx_delete(l_tx);
- return NULL;
- }
+ if (s_tx_trackers_add(&l_tx, a_trackers)) {
+ dap_chain_datum_tx_delete(l_tx);
+ return NULL;
}
dap_chain_datum_t *l_datum_tx = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, dap_chain_datum_tx_get_size(l_tx));
dap_chain_datum_tx_delete(l_tx);
@@ -608,29 +621,9 @@ dap_chain_datum_t *s_cond_tx_create(dap_chain_tx_out_cond_t *a_cond, dap_chain_t
dap_chain_datum_tx_delete(l_tx);
return NULL;
}
- for (dap_list_t *it = a_trackers; it; it = it->next) {
- dap_ledger_tracker_t *l_tracker = it->data;
- dap_chain_tx_tsd_t *l_tracker_hash_tsd = dap_chain_datum_tx_item_tsd_create(&l_tracker->voting_hash, DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_VOTING_HASH, sizeof(dap_hash_fast_t));
- if (!l_tracker_hash_tsd) {
- dap_chain_datum_tx_delete(l_tx);
- return NULL;
- }
- if (dap_chain_datum_tx_add_item(&l_tx, l_tracker_hash_tsd) != 1) {
- dap_chain_datum_tx_delete(l_tx);
- return NULL;
- }
- for (dap_ledger_tracker_item_t *l_item = l_tracker->items; l_item; l_item = l_item->next) {
- dap_ledger_hardfork_tracker_t l_hardfork_tracker = { .pkey_hash = l_item->pkey_hash, .coloured_value = l_item->coloured_value };
- dap_chain_tx_tsd_t *l_tracker_tsd = dap_chain_datum_tx_item_tsd_create(&l_hardfork_tracker, DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_TRACKER, sizeof(dap_ledger_hardfork_tracker_t));
- if (!l_tracker_tsd) {
- dap_chain_datum_tx_delete(l_tx);
- return NULL;
- }
- if (dap_chain_datum_tx_add_item(&l_tx, l_tracker_tsd) != 1) {
- dap_chain_datum_tx_delete(l_tx);
- return NULL;
- }
- }
+ if (s_tx_trackers_add(&l_tx, a_trackers)) {
+ dap_chain_datum_tx_delete(l_tx);
+ return NULL;
}
dap_chain_datum_t *l_datum_tx = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, dap_chain_datum_tx_get_size(l_tx));
dap_chain_datum_tx_delete(l_tx);
@@ -980,7 +973,7 @@ int s_hardfork_check(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t a_
} break;
case DAP_CHAIN_DATUM_TX_TSD_TYPE_HARDFORK_TRACKER: {
if (l_tsd->size != sizeof(dap_ledger_hardfork_tracker_t)) {
- log_it(L_WARNING, "Illegal harfork datum tx TSD VOTING_HASH size %u", l_tsd->size);
+ log_it(L_WARNING, "Illegal harfork datum tx TSD TRACKER size %u", l_tsd->size);
m_ret_clear(-8);
}
if (!l_tracker_current) {
diff --git a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
index 52785a8f62a32f692b55608cfbc4eae2781fabb5..6cf41102d09b5db692e4af67c9dd4a998aa929e5 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
@@ -787,7 +787,7 @@ static int s_pos_delegate_purge(dap_chain_net_id_t a_net_id, void *a_service_int
dap_global_db_erase_table(l_gdb_group, NULL, NULL);
DAP_DELETE(l_gdb_group);
char *l_approved_group = s_get_approved_group(l_net);
- dap_global_db_erase_table(l_approved_group, NULL, NULL);
+ dap_global_db_erase_table_sync(l_approved_group);
DAP_DELETE(l_approved_group);
struct srv_stake *l_srv_stake = (struct srv_stake *)a_service_internal;
@@ -1602,7 +1602,7 @@ void dap_chain_net_srv_stake_remove_approving_decree_info(dap_chain_net_t *a_net
// func work
char *l_delegated_group = s_get_approved_group(a_net);
const char *l_tx_hash_str = dap_chain_hash_fast_to_str_static(&l_stake->tx_hash);
- dap_global_db_del_sync(l_delegated_group, l_tx_hash_str);
+ dap_global_db_del(l_delegated_group, l_tx_hash_str, NULL, NULL);
DAP_DEL_Z(l_delegated_group);
}
diff --git a/modules/service/voting/dap_chain_net_srv_voting.c b/modules/service/voting/dap_chain_net_srv_voting.c
index 3965207130414736b2fa26d05bf9bc74c98bd89f..0ec7680f8ac3f5776ff155a4323cdd02854b383d 100644
--- a/modules/service/voting/dap_chain_net_srv_voting.c
+++ b/modules/service/voting/dap_chain_net_srv_voting.c
@@ -84,16 +84,16 @@ int dap_chain_net_srv_voting_init()
{
dap_ledger_voting_verificator_add(s_voting_verificator, s_vote_verificator,
s_datum_tx_voting_verification_delete_callback, dap_chain_net_srv_voting_get_expiration_time);
- dap_cli_server_cmd_add("voting", s_cli_voting, "Voting commands.",
- "voting create -net <net_name> -question <\"Question_string\"> -options <\"Option0\", \"Option1\" ... \"OptionN\"> [-expire <voting_expire_time_in_RCF822>] [-max_votes_count <Votes_count>] [-delegated_key_required] [-vote_changing_allowed] -fee <value> -w <fee_wallet_name>\n"
- "voting vote -net <net_name> -hash <voting_hash> -option_idx <option_index> [-cert <delegate_cert_name>] -fee <value> -w <fee_wallet_name> [-token <ticker>]\n"
- "voting list -net <net_name>\n"
- "voting dump -net <net_name> -hash <voting_hash>\n"
+ dap_cli_server_cmd_add("poll", s_cli_voting, "Voting/poll commands",
+ "poll create -net <net_name> -question <\"Question_string\"> -options <\"Option0\", \"Option1\" ... \"OptionN\"> [-expire <poll_expire_time_in_RCF822>] [-max_votes_count <votes_count>]"
+ " [-delegated_key_required] [-vote_changing_allowed] -fee <value> -w <fee_wallet_name> [-token <ticker>]\n"
+ "poll vote -net <net_name> -hash <poll_hash> -option_idx <option_index> [-cert <delegate_cert_name>] -fee <value> -w <fee_wallet_name>\n"
+ "poll list -net <net_name>\n"
+ "poll dump -net <net_name> -hash <poll_hash>\n"
"Hint:\n"
"\texample value_coins (only natural) 1.0 123.4567\n"
"\texample value_datoshi (only integer) 1 20 0.4321e+4\n");
-
dap_chain_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_VOTING_ID };
dap_chain_static_srv_callbacks_t l_srv_callbacks = { .start = s_callback_start,
.purge = s_callback_purge,
@@ -102,7 +102,7 @@ int dap_chain_net_srv_voting_init()
};
int ret = dap_chain_srv_add(l_uid, DAP_CHAIN_SRV_VOTING_LITERAL, &l_srv_callbacks);
if (ret) {
- log_it(L_ERROR, "Can't register voting service");
+ log_it(L_ERROR, "Can't register poll service");
return ret;
}
dap_ledger_service_add(l_uid, DAP_CHAIN_SRV_VOTING_LITERAL, s_tag_check_voting);
@@ -145,7 +145,7 @@ static inline struct voting *s_votings_ht_get(dap_chain_net_id_t a_net_id)
{
struct srv_voting *l_service_internal = dap_chain_srv_get_internal(a_net_id, (dap_chain_srv_uid_t) { .uint64 = DAP_CHAIN_NET_SRV_VOTING_ID });
if (!l_service_internal) {
- log_it(L_ERROR, "Can't find voting service for net id 0x%016" DAP_UINT64_FORMAT_x, a_net_id.uint64);
+ log_it(L_ERROR, "Can't find poll service for net id 0x%016" DAP_UINT64_FORMAT_x, a_net_id.uint64);
return NULL;
}
return l_service_internal->ht;
@@ -175,13 +175,13 @@ static inline bool s_voting_delete(dap_chain_net_id_t a_net_id, dap_hash_fast_t
{
struct srv_voting *l_service_internal = dap_chain_srv_get_internal(a_net_id, (dap_chain_srv_uid_t) { .uint64 = DAP_CHAIN_NET_SRV_VOTING_ID });
if (!l_service_internal) {
- log_it(L_ERROR, "Can't find voting service for net id 0x%016" DAP_UINT64_FORMAT_x, a_net_id.uint64);
+ log_it(L_ERROR, "Can't find poll service for net id 0x%016" DAP_UINT64_FORMAT_x, a_net_id.uint64);
return false;
}
struct voting *l_voting = NULL;
HASH_FIND(hh, l_service_internal->ht, a_voting_hash, sizeof(dap_hash_fast_t), l_voting);
if (!l_voting) {
- log_it(L_ERROR, "Can't find voting %s", dap_hash_fast_to_str_static(a_voting_hash));
+ log_it(L_ERROR, "Can't find poll %s", dap_hash_fast_to_str_static(a_voting_hash));
return false;
}
HASH_DEL(l_service_internal->ht, l_voting);
@@ -196,7 +196,7 @@ uint64_t *dap_chain_net_srv_voting_get_result(dap_ledger_t *a_ledger, dap_chain_
dap_return_val_if_fail(a_ledger && a_voting_hash, NULL);
struct voting *l_voting = s_voting_find(a_ledger->net->pub.id, a_voting_hash);
if (!l_voting) {
- log_it(L_ERROR, "Can't find voting with hash %s in net %s", dap_hash_fast_to_str_static(a_voting_hash), a_ledger->net->pub.name);
+ log_it(L_ERROR, "Can't find poll with hash %s in net %s", dap_hash_fast_to_str_static(a_voting_hash), a_ledger->net->pub.name);
return NULL;
}
size_t l_options_count = dap_list_length(l_voting->params->options);
@@ -205,7 +205,7 @@ uint64_t *dap_chain_net_srv_voting_get_result(dap_ledger_t *a_ledger, dap_chain_
for (dap_list_t *it = l_voting->votes; it; it = it->next) {
struct vote *l_vote = it->data;
if (l_vote->answer_idx >= l_options_count) {
- log_it(L_ERROR, "Answers option index %" DAP_UINT64_FORMAT_U " is higher than options count %zu for voting %s",
+ log_it(L_ERROR, "Answers option index %" DAP_UINT64_FORMAT_U " is higher than options count %zu for poll %s",
l_vote->answer_idx, l_options_count, dap_hash_fast_to_str_static(a_voting_hash));
continue;
}
@@ -219,7 +219,7 @@ dap_time_t dap_chain_net_srv_voting_get_expiration_time(dap_ledger_t *a_ledger,
dap_return_val_if_fail(a_ledger && a_voting_hash, 0);
struct voting *l_voting = s_voting_find(a_ledger->net->pub.id, a_voting_hash);
if (!l_voting) {
- log_it(L_ERROR, "Can't find voting with hash %s in net %s", dap_hash_fast_to_str_static(a_voting_hash), a_ledger->net->pub.name);
+ log_it(L_ERROR, "Can't find poll with hash %s in net %s", dap_hash_fast_to_str_static(a_voting_hash), a_ledger->net->pub.name);
return 0;
}
return l_voting->params->voting_expire;
@@ -238,52 +238,52 @@ static int s_voting_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_
dap_tsd_t *l_tsd = (dap_tsd_t *)l_tx_tsd->tsd;
if (l_tx_tsd->header.size < sizeof(dap_tsd_t) ||
l_tx_tsd->header.size != dap_tsd_size(l_tsd)) {
- log_it(L_WARNING, "Incorrect size %" DAP_UINT64_FORMAT_U " of TX_TSD item for voting %s",
+ log_it(L_WARNING, "Incorrect size %" DAP_UINT64_FORMAT_U " of TX_TSD item for poll %s",
l_tx_tsd->header.size, dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_INVALID_SIZE;
}
switch(l_tsd->type) {
case VOTING_TSD_TYPE_QUESTION:
if (!l_tsd->size || *l_tsd->data == '\0') {
- log_it(L_WARNING, "Invalid content for string TSD section QUESTION of voting %s", dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Invalid content for string TSD section QUESTION of poll %s", dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_PARSE_ERROR;
}
l_question_present = true;
break;
case VOTING_TSD_TYPE_OPTION:
if (!l_tsd->size || *l_tsd->data == '\0') {
- log_it(L_WARNING, "Invalid content for string TSD section ANSWER of voting %s", dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Invalid content for string TSD section ANSWER of poll %s", dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_PARSE_ERROR;
}
l_options_present = true;
break;
case VOTING_TSD_TYPE_EXPIRE:
if (l_tsd->size != sizeof(dap_time_t)) {
- log_it(L_WARNING, "Incorrect size %u of TSD section EXPIRE of voting %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Incorrect size %u of TSD section EXPIRE of poll %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_INVALID_SIZE;
}
break;
case VOTING_TSD_TYPE_MAX_VOTES_COUNT:
if (l_tsd->size != sizeof(uint64_t)) {
- log_it(L_WARNING, "Incorrect size %u of TSD section MAX_VOTES_COUNT of voting %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Incorrect size %u of TSD section MAX_VOTES_COUNT of poll %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_INVALID_SIZE;
}
break;
case VOTING_TSD_TYPE_DELEGATED_KEY_REQUIRED:
if (l_tsd->size != sizeof(byte_t)) {
- log_it(L_WARNING, "Incorrect size %u of TSD section DELEGATED_KEY_REQUIRED of voting %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Incorrect size %u of TSD section DELEGATED_KEY_REQUIRED of poll %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_INVALID_SIZE;
}
break;
case VOTING_TSD_TYPE_VOTE_CHANGING_ALLOWED:
if (l_tsd->size != sizeof(byte_t)) {
- log_it(L_WARNING, "Incorrect size %u of TSD section VOTE_CHANGING_ALLOWED of voting %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Incorrect size %u of TSD section VOTE_CHANGING_ALLOWED of poll %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_INVALID_SIZE;
}
break;
case VOTING_TSD_TYPE_TOKEN:
if (!l_tsd->size || l_tsd->size >= DAP_CHAIN_TICKER_SIZE_MAX) {
- log_it(L_WARNING, "Incorrect size %u of TSD section TOKEN for voting %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Incorrect size %u of TSD section TOKEN for poll %s", l_tsd->size, dap_hash_fast_to_str_static(a_tx_hash));
return -DAP_LEDGER_CHECK_INVALID_SIZE;
}
default:
@@ -292,7 +292,7 @@ static int s_voting_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_
}
if (!l_question_present || !l_options_present) {
- log_it(L_WARNING, "Voting with hash %s contain no question or answer options", dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_WARNING, "Poll with hash %s contain no question or answer options", dap_hash_fast_to_str_static(a_tx_hash));
return -2;
}
@@ -309,7 +309,7 @@ static int s_voting_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_
strcpy(l_item->params->token_ticker, a_ledger->net->pub.native_ticker);
s_voting_add(a_ledger->net->pub.id, l_item);
- log_it(L_NOTICE, "Voting with hash %s succefully added to ledger", dap_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_NOTICE, "Poll with hash %s succefully added to ledger", dap_hash_fast_to_str_static(a_tx_hash));
return DAP_LEDGER_CHECK_OK;
}
@@ -321,7 +321,7 @@ static int s_vote_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
struct voting *l_voting = s_voting_find(a_ledger->net->pub.id, &l_vote_tx_item->voting_hash);
if (!l_voting) {
- log_it(L_ERROR, "Can't find voting with hash %s in net %s",
+ log_it(L_ERROR, "Can't find poll with hash %s in net %s",
dap_chain_hash_fast_to_str_static(&l_vote_tx_item->voting_hash), a_ledger->net->pub.name);
return -5;
}
@@ -348,17 +348,17 @@ static int s_vote_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
return -6;
}
if (l_voting->params->votes_max_count && dap_list_length(l_voting->votes) >= l_voting->params->votes_max_count){
- log_it(L_WARNING, "The required number of votes has been collected for voting %s", dap_chain_hash_fast_to_str_static(&l_voting->hash));
+ log_it(L_WARNING, "The required number of votes has been collected for poll %s", dap_chain_hash_fast_to_str_static(&l_voting->hash));
return -7;
}
if (l_voting->params->voting_expire && l_voting->params->voting_expire <= a_tx_in->header.ts_created) {
- log_it(L_WARNING, "The voting %s has been expired", dap_chain_hash_fast_to_str_static(&l_voting->hash));
+ log_it(L_WARNING, "The poll %s has been expired", dap_chain_hash_fast_to_str_static(&l_voting->hash));
return -8;
}
if (l_voting->params->delegate_key_required &&
!dap_chain_net_srv_stake_check_pkey_hash(a_ledger->net->pub.id, &l_pkey_hash)){
- log_it(L_WARNING, "Voting %s required a delegated key", dap_chain_hash_fast_to_str_static(&l_voting->hash));
+ log_it(L_WARNING, "Poll %s required a delegated key", dap_chain_hash_fast_to_str_static(&l_voting->hash));
return -10;
}
@@ -369,7 +369,7 @@ static int s_vote_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
if (!l_voting->params->vote_changing_allowed) {
char l_vote_hash_str[DAP_HASH_FAST_STR_SIZE];
dap_hash_fast_to_str(l_vote_hash, l_vote_hash_str, DAP_HASH_FAST_STR_SIZE);
- log_it(L_WARNING, "The voting %s don't allow change your vote %s",
+ log_it(L_WARNING, "The poll %s don't allow change your vote %s",
dap_hash_fast_to_str_static(&l_voting->hash), l_vote_hash_str);
return -11;
}
@@ -413,7 +413,7 @@ static int s_vote_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
uint256_t l_uncoloured_value = dap_ledger_coin_get_uncoloured_value(a_ledger, &l_vote_tx_item->voting_hash, &l_tx_hash, l_out_idx,
l_vote_overwrited ? &l_pkey_hash : NULL);
if (IS_ZERO_256(l_uncoloured_value)) {
- log_it(L_ERROR, "Coin with OUT number %d of tx %s is voted before in voting %s", l_out_idx, dap_chain_hash_fast_to_str_static(&l_tx_hash),
+ log_it(L_ERROR, "Coin with OUT number %d of tx %s is voted before in poll %s", l_out_idx, dap_chain_hash_fast_to_str_static(&l_tx_hash),
dap_chain_hash_fast_to_str_static(&l_vote_tx_item->voting_hash));
return -13;
}
@@ -424,7 +424,7 @@ static int s_vote_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
}
if (IS_ZERO_256(l_weight) && !l_vote_overwrited) {
- log_it(L_ERROR, "No uncoloured inputs in vote %s of voting %s", dap_chain_hash_fast_to_str_static(a_tx_hash),
+ log_it(L_ERROR, "No uncoloured inputs in vote %s of poll %s", dap_chain_hash_fast_to_str_static(a_tx_hash),
dap_chain_hash_fast_to_str_static(&l_vote_tx_item->voting_hash));
return -14;
}
@@ -441,10 +441,10 @@ static int s_vote_verificator(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx
const char *l_vote_hash_str = dap_hash_fast_to_str_static(&((struct vote *)l_vote_overwrited->data)->vote_hash);
DAP_DELETE(l_vote_overwrited->data);
l_voting->votes = dap_list_delete_link(l_voting->votes, l_vote_overwrited);
- log_it(L_NOTICE, "Vote %s of voting %s has been changed", l_vote_hash_str, dap_hash_fast_to_str_static(&l_voting->hash));
+ log_it(L_NOTICE, "Vote %s of poll %s has been changed", l_vote_hash_str, dap_hash_fast_to_str_static(&l_voting->hash));
} else {
const char *l_vote_hash_str = dap_hash_fast_to_str_static(a_tx_hash);
- log_it(L_NOTICE, "Vote %s of voting %s has been accepted", l_vote_hash_str, dap_hash_fast_to_str_static(&l_voting->hash));
+ log_it(L_NOTICE, "Vote %s of poll %s has been accepted", l_vote_hash_str, dap_hash_fast_to_str_static(&l_voting->hash));
}
l_voting->votes = dap_list_append(l_voting->votes, l_vote_item);
@@ -461,7 +461,7 @@ static inline bool s_vote_delete(dap_chain_net_id_t a_net_id, dap_chain_datum_tx
assert(l_vote_tx_item);
struct voting * l_voting = s_voting_find(a_net_id, &l_vote_tx_item->voting_hash);
if (!l_voting) {
- log_it(L_ERROR, "Can't find voting with hash %s in net id 0x%016" DAP_UINT64_FORMAT_x,
+ log_it(L_ERROR, "Can't find poll with hash %s in net id 0x%016" DAP_UINT64_FORMAT_x,
dap_chain_hash_fast_to_str_static(a_vote_tx_hash), a_net_id.uint64);
return false;
}
@@ -484,7 +484,7 @@ static bool s_datum_tx_voting_verification_delete_callback(dap_ledger_t *a_ledge
if (a_type == TX_ITEM_TYPE_VOTE)
return s_vote_delete(a_ledger->net->pub.id, a_tx_in, a_tx_hash);
- log_it(L_ERROR, "Unknown voting type %d fot tx_hash %s", a_type, dap_chain_hash_fast_to_str_static(a_tx_hash));
+ log_it(L_ERROR, "Unknown poll type %d fot tx_hash %s", a_type, dap_chain_hash_fast_to_str_static(a_tx_hash));
return false;
}
@@ -580,45 +580,28 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-question", &l_question_str);
if (!l_question_str){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_QUESTION_PARAM_MISSING, "Voting requires a question parameter to be valid.");
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_QUESTION_PARAM_MISSING, "Poll requires a question parameter to be valid.");
return -DAP_CHAIN_NET_VOTE_CREATE_QUESTION_PARAM_MISSING;
}
-
- if (strlen(l_question_str) > DAP_CHAIN_DATUM_TX_VOTING_QUESTION_MAX_LENGTH){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_QUESTION_CONTAIN_MAX_CHARACTERS,
- "The question must contain no more than %d characters", DAP_CHAIN_DATUM_TX_VOTING_QUESTION_MAX_LENGTH);
- return -DAP_CHAIN_NET_VOTE_CREATE_QUESTION_CONTAIN_MAX_CHARACTERS;
- }
-
dap_list_t *l_options_list = NULL;
dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-options", &l_options_list_str);
if (!l_options_list_str){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_OPTION_PARAM_MISSING, "Voting requires a question parameter to be valid.");
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_OPTION_PARAM_MISSING, "Poll requires a question parameter to be valid.");
return -DAP_CHAIN_NET_VOTE_CREATE_OPTION_PARAM_MISSING;
}
// Parse options list
l_options_list = s_get_options_list_from_str(l_options_list_str);
- if(!l_options_list || dap_list_length(l_options_list) < 2){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR, "Number of options must be 2 or greater.");
- return -DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR;
- }
-
- if(dap_list_length(l_options_list)>DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_COUNT){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CONTAIN_MAX_OPTIONS,
- "The voting can contain no more than %d options", DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_COUNT);
- return -DAP_CHAIN_NET_VOTE_CREATE_CONTAIN_MAX_OPTIONS;
- }
dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-fee", &l_fee_str);
if (!l_fee_str){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_FEE_PARAM_NOT_VALID, "Voting requires paramete -fee to be valid.");
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_FEE_PARAM_NOT_VALID, "Poll requires parameter -fee to be valid.");
return -DAP_CHAIN_NET_VOTE_CREATE_FEE_PARAM_NOT_VALID;
}
uint256_t l_value_fee = dap_chain_balance_scan(l_fee_str);
dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-w", &l_wallet_str);
if (!l_wallet_str){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_WALLET_PARAM_NOT_VALID, "Voting requires parameter -w to be valid.");
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_WALLET_PARAM_NOT_VALID, "Poll requires parameter -w to be valid.");
return -DAP_CHAIN_NET_VOTE_CREATE_WALLET_PARAM_NOT_VALID;
}
@@ -663,76 +646,64 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
dap_chain_wallet_close(l_wallet_fee);
switch (res) {
- case DAP_CHAIN_NET_VOTE_CREATE_OK: {
- json_object* json_obj_inf = json_object_new_object();
- json_object_object_add(json_obj_inf, "datum_add_successfully", json_object_new_string(l_hash_ret));
- json_object_array_add(*json_arr_reply, json_obj_inf);
- DAP_DELETE(l_hash_ret);
- return DAP_CHAIN_NET_VOTE_CREATE_OK;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX, "The question must contain no more than %d characters",
- DAP_CHAIN_DATUM_TX_VOTING_QUESTION_MAX_LENGTH);
- return DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX, "The voting can contain no more than %d options",
- DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_COUNT);
- return DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_FEE_IS_ZERO: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_FEE_IS_ZERO, "The commission amount must be greater than zero");
- return DAP_CHAIN_NET_VOTE_CREATE_FEE_IS_ZERO;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_SOURCE_ADDRESS_IS_INVALID: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_SOURCE_ADDRESS_IS_INVALID, "source address is invalid");
- return DAP_CHAIN_NET_VOTE_CREATE_SOURCE_ADDRESS_IS_INVALID;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_NOT_ENOUGH_FUNDS_TO_TRANSFER: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_NOT_ENOUGH_FUNDS_TO_TRANSFER, "Not enough funds to transfer");
- return DAP_CHAIN_NET_VOTE_CREATE_NOT_ENOUGH_FUNDS_TO_TRANSFER;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_MAX_COUNT_OPTION_EXCEEDED: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_MAX_COUNT_OPTION_EXCEEDED, "The option must contain no more than %d characters",
- DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_LENGTH);
- return DAP_CHAIN_NET_VOTE_CREATE_MAX_COUNT_OPTION_EXCEEDED;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_OPTION_TSD_ITEM: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_OPTION_TSD_ITEM, "Can't create voting with expired time");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_OPTION_TSD_ITEM;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_INPUT_TIME_MORE_CURRENT_TIME: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_INPUT_TIME_MORE_CURRENT_TIME, "Can't create voting with expired time");
- return DAP_CHAIN_NET_VOTE_CREATE_INPUT_TIME_MORE_CURRENT_TIME;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_EXPIRE_TIME: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_EXPIRE_TIME, "Can't create expired tsd item.");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_EXPIRE_TIME;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_DELEGATE_KEY: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_DELEGATE_KEY, "Can't create delegated key req tsd item.");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_DELEGATE_KEY;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_NET_FEE_OUT: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_NET_FEE_OUT, "Can't add net fee out.");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_NET_FEE_OUT;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_OUT_WITH_VALUE_BACK: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_OUT_WITH_VALUE_BACK, "Can't add out with value back");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_OUT_WITH_VALUE_BACK;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX, "Can not sign transaction");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX;
- } break;
- case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL, "Can not pool transaction in mempool");
- return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL;
- } break;
- default: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_SRV_VOTING_UNKNOWN_ERR, "Unknown error. Code: %d", res);
- return -DAP_CHAIN_NET_SRV_VOTING_UNKNOWN_ERR;
- }
+ case DAP_CHAIN_NET_VOTE_CREATE_OK: {
+ json_object* json_obj_inf = json_object_new_object();
+ json_object_object_add(json_obj_inf, "datum_add_successfully", json_object_new_string(l_hash_ret));
+ json_object_array_add(*json_arr_reply, json_obj_inf);
+ DAP_DELETE(l_hash_ret);
+ return DAP_CHAIN_NET_VOTE_CREATE_OK;
+ }
+ case DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX, "The question must contain no more than %d characters",
+ DAP_CHAIN_DATUM_TX_VOTING_QUESTION_MAX_LENGTH);
+ return DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX;
+ case DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR, "Number of options must be 2 or greater.");
+ return DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR;
+ case DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX, "The poll can contain no more than %d options",
+ DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_COUNT);
+ return DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX;
+ case DAP_CHAIN_NET_VOTE_CREATE_FEE_IS_ZERO:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_FEE_IS_ZERO, "The commission amount must be greater than zero");
+ return DAP_CHAIN_NET_VOTE_CREATE_FEE_IS_ZERO;
+ case DAP_CHAIN_NET_VOTE_CREATE_SOURCE_ADDRESS_IS_INVALID:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_SOURCE_ADDRESS_IS_INVALID, "source address is invalid");
+ return DAP_CHAIN_NET_VOTE_CREATE_SOURCE_ADDRESS_IS_INVALID;
+ case DAP_CHAIN_NET_VOTE_CREATE_NOT_ENOUGH_FUNDS_TO_TRANSFER:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_NOT_ENOUGH_FUNDS_TO_TRANSFER, "Not enough funds to transfer");
+ return DAP_CHAIN_NET_VOTE_CREATE_NOT_ENOUGH_FUNDS_TO_TRANSFER;
+ case DAP_CHAIN_NET_VOTE_CREATE_MAX_COUNT_OPTION_EXCEEDED:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_MAX_COUNT_OPTION_EXCEEDED, "The option must contain no more than %d characters",
+ DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_LENGTH);
+ return DAP_CHAIN_NET_VOTE_CREATE_MAX_COUNT_OPTION_EXCEEDED;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_OPTION_TSD_ITEM:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_OPTION_TSD_ITEM, "Can't create poll with expired time");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_OPTION_TSD_ITEM;
+ case DAP_CHAIN_NET_VOTE_CREATE_INPUT_TIME_MORE_CURRENT_TIME:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_INPUT_TIME_MORE_CURRENT_TIME, "Can't create poll with expired time");
+ return DAP_CHAIN_NET_VOTE_CREATE_INPUT_TIME_MORE_CURRENT_TIME;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_EXPIRE_TIME:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_EXPIRE_TIME, "Can't create expired tsd item.");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_EXPIRE_TIME;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_DELEGATE_KEY:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_DELEGATE_KEY, "Can't create delegated key req tsd item.");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_CREATE_TSD_DELEGATE_KEY;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_NET_FEE_OUT:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_NET_FEE_OUT, "Can't add net fee out.");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_NET_FEE_OUT;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_OUT_WITH_VALUE_BACK:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_OUT_WITH_VALUE_BACK, "Can't add out with value back");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_ADD_OUT_WITH_VALUE_BACK;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX, "Can not sign transaction");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX;
+ case DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL, "Can not pool transaction in mempool");
+ return DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL;
+ default:
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_SRV_VOTING_UNKNOWN_ERR, "Unknown error. Code: %d", res);
+ return -DAP_CHAIN_NET_SRV_VOTING_UNKNOWN_ERR;
}
}break;
case CMD_VOTE:{
@@ -811,18 +782,18 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
return DAP_CHAIN_NET_VOTE_CREATE_OK;
} break;
case DAP_CHAIN_NET_VOTE_VOTING_CAN_NOT_FIND_VOTE: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_CAN_NOT_FIND_VOTE, "Can't find voting with hash %s", l_hash_str);
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_CAN_NOT_FIND_VOTE, "Can't find poll with hash %s", l_hash_str);
} break;
case DAP_CHAIN_NET_VOTE_VOTING_THIS_VOTING_HAVE_MAX_VALUE_VOTES: {
dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_THIS_VOTING_HAVE_MAX_VALUE_VOTES,
- "This voting already received the required number of votes.");
+ "This poll already received the required number of votes.");
} break;
case DAP_CHAIN_NET_VOTE_VOTING_ALREADY_EXPIRED: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_ALREADY_EXPIRED, "This voting already expired.");
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_ALREADY_EXPIRED, "This poll is already expired.");
} break;
case DAP_CHAIN_NET_VOTE_VOTING_CERT_REQUIRED: {
dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_CERT_REQUIRED,
- "This voting required a delegated key. Parameter -cert must contain a valid certificate name");
+ "This poll required a delegated key. Parameter -cert must contain a valid certificate name");
} break;
case DAP_CHAIN_NET_VOTE_VOTING_NO_KEY_FOUND_IN_CERT: {
dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_NO_KEY_FOUND_IN_CERT,
@@ -833,7 +804,7 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_KEY_IS_NOT_DELEGATED, "Your key is not delegated.");
} break;
case DAP_CHAIN_NET_VOTE_VOTING_DOES_NOT_ALLOW_CHANGE_YOUR_VOTE: {
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_DOES_NOT_ALLOW_CHANGE_YOUR_VOTE, "The voting doesn't allow change your vote.");
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_DOES_NOT_ALLOW_CHANGE_YOUR_VOTE, "The poll doesn't allow change your vote.");
} break;
case DAP_CHAIN_NET_VOTE_VOTING_SOURCE_ADDRESS_INVALID: {
dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_VOTING_SOURCE_ADDRESS_INVALID, "source address is invalid");
@@ -878,12 +849,12 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
case CMD_LIST: {
json_object* json_vote_out = json_object_new_object();
- json_object_object_add(json_vote_out, "list_of_votings", json_object_new_string(l_net->pub.name));
+ json_object_object_add(json_vote_out, "list_of_polls", json_object_new_string(l_net->pub.name));
json_object* json_arr_voting_out = json_object_new_array();
struct voting *votings_ht = s_votings_ht_get(l_net->pub.id);
for (struct voting *it = votings_ht; it; it = it->hh.next) {
json_object* json_obj_vote = json_object_new_object();
- json_object_object_add( json_obj_vote, "voting_tx",
+ json_object_object_add( json_obj_vote, "poll_tx",
json_object_new_string_len(dap_chain_hash_fast_to_str_static(&it->hash), sizeof(dap_hash_str_t)) );
json_object_object_add( json_obj_vote, "question",
json_object_new_string(it->params->question) );
@@ -909,7 +880,7 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
}
struct voting *l_voting = s_voting_find(l_net->pub.id, &l_voting_hash);
if(!l_voting){
- dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_DUMP_CAN_NOT_FIND_VOTE, "Can't find voting with hash %s", l_hash_str);
+ dap_json_rpc_error_add(*json_arr_reply, DAP_CHAIN_NET_VOTE_DUMP_CAN_NOT_FIND_VOTE, "Can't find poll with hash %s", l_hash_str);
return -DAP_CHAIN_NET_VOTE_DUMP_CAN_NOT_FIND_VOTE;
}
@@ -935,7 +906,7 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
}
json_object* json_vote_out = json_object_new_object();
- json_object_object_add(json_vote_out, "voting_tx", json_object_new_string_len(l_hash_str, sizeof(dap_hash_str_t)));
+ json_object_object_add(json_vote_out, "poll_tx", json_object_new_string_len(l_hash_str, sizeof(dap_hash_str_t)));
json_object_object_add(json_vote_out, "question", json_object_new_string(l_voting->params->question));
json_object_object_add(json_vote_out, "token", json_object_new_string(l_voting->params->token_ticker));
if (l_voting->params->voting_expire) {
@@ -962,19 +933,19 @@ static int s_cli_voting(int a_argc, char **a_argv, void **a_str_reply)
for (dap_list_t *l_option = l_voting->params->options; l_option; l_option = l_option->next, ++i) {
json_object* json_vote_obj = json_object_new_object();
json_object_object_add(json_vote_obj, "option_id", json_object_new_int(i));
- json_object_object_add( json_vote_obj, "vote_tx", json_object_new_string(l_option->data) );
- json_object_object_add(json_vote_obj, "voting_power", json_object_new_uint64( l_results[i].num_of_votes) );
- int l_percentage = l_votes_count ? (int)((float)l_results[i].num_of_votes/l_votes_count * 100 + 0.5) : 0;
- json_object_object_add(json_vote_obj, "vote_share", json_object_new_int(l_percentage) );
+ json_object_object_add( json_vote_obj, "option_text", json_object_new_string(l_option->data) );
+ json_object_object_add(json_vote_obj, "votes_count", json_object_new_uint64( l_results[i].num_of_votes) );
+ int l_percentage = l_votes_count ? ((double)(l_results[i].num_of_votes * 100))/l_votes_count + 0.5 : 0;
+ json_object_object_add(json_vote_obj, "votes_percent", json_object_new_int(l_percentage) );
uint256_t l_weight_percentage = { };
DIV_256_COIN(l_results[i].weights, l_total_weight, &l_weight_percentage);
MULT_256_COIN(l_weight_percentage, dap_chain_balance_coins_scan("100.0"), &l_weight_percentage);
const char *l_weight_percentage_str = dap_uint256_decimal_to_round_char(l_weight_percentage, 2, true),
*l_w_coins, *l_w_datoshi = dap_uint256_to_char(l_results[i].weights, &l_w_coins);
- json_object_object_add(json_vote_obj, "vote_sum", json_object_new_string(l_w_coins));
- json_object_object_add(json_vote_obj, "vote_sum_datoshi", json_object_new_string(l_w_datoshi));
- json_object_object_add(json_vote_obj, "vote_sum_weight", json_object_new_string(l_weight_percentage_str));
+ json_object_object_add(json_vote_obj, "votes_sum", json_object_new_string(l_w_coins));
+ json_object_object_add(json_vote_obj, "votes_sum_datoshi", json_object_new_string(l_w_datoshi));
+ json_object_object_add(json_vote_obj, "votes_sum_weight", json_object_new_string(l_weight_percentage_str));
json_object_array_add(json_arr_vote_out, json_vote_obj);
}
json_object_object_add(json_vote_out, "results", json_arr_vote_out);
@@ -1001,6 +972,9 @@ int dap_chain_net_srv_voting_create(const char *a_question, dap_list_t *a_option
return DAP_CHAIN_NET_VOTE_CREATE_LENGTH_QUESTION_OVERSIZE_MAX;
// Parse options list
+ if (!a_options || dap_list_length(a_options) < 2)
+ return -DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR;
+
if (dap_list_length(a_options) > DAP_CHAIN_DATUM_TX_VOTING_OPTION_MAX_COUNT)
return DAP_CHAIN_NET_VOTE_CREATE_COUNT_OPTION_OVERSIZE_MAX;
diff --git a/modules/service/voting/include/dap_chain_net_srv_voting.h b/modules/service/voting/include/dap_chain_net_srv_voting.h
index 1fc6505066be9f82874f33500c10271ea4320178..8bc6f6ef3d00711b12995e16f7900af5b9c785b2 100644
--- a/modules/service/voting/include/dap_chain_net_srv_voting.h
+++ b/modules/service/voting/include/dap_chain_net_srv_voting.h
@@ -75,10 +75,8 @@ enum DAP_CHAIN_NET_SRV_VOTING_CLI_ERRORS {
DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_SIGNED_TX,
DAP_CHAIN_NET_VOTE_CREATE_CAN_NOT_POOL_DATUM_IN_MEMPOOL,
DAP_CHAIN_NET_VOTE_CREATE_QUESTION_PARAM_MISSING,
- DAP_CHAIN_NET_VOTE_CREATE_QUESTION_CONTAIN_MAX_CHARACTERS,
DAP_CHAIN_NET_VOTE_CREATE_OPTION_PARAM_MISSING,
DAP_CHAIN_NET_VOTE_CREATE_NUMBER_OPTIONS_ERROR,
- DAP_CHAIN_NET_VOTE_CREATE_CONTAIN_MAX_OPTIONS,
DAP_CHAIN_NET_VOTE_CREATE_FEE_PARAM_NOT_VALID,
DAP_CHAIN_NET_VOTE_CREATE_WALLET_PARAM_NOT_VALID,
DAP_CHAIN_NET_VOTE_CREATE_WALLET_DOES_NOT_EXIST,
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index d7fdc8b8a8b06597ce8a4b083bafcdcb3a58c96b..156d5c81b70d522d061ff57f1b17af92c86e84d1 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -392,7 +392,8 @@ static int s_chain_cs_blocks_new(dap_chain_t *a_chain, dap_config_t *a_chain_con
dap_chain_block_cache_t * dap_chain_block_cache_get_by_hash(dap_chain_cs_blocks_t * a_blocks, dap_chain_hash_fast_t *a_block_hash)
{
dap_chain_block_cache_t * l_ret = NULL;
- pthread_rwlock_rdlock(& PVT(a_blocks)->rwlock);
+ int err = pthread_rwlock_rdlock(& PVT(a_blocks)->rwlock);
+ assert(!err);
HASH_FIND(hh, PVT(a_blocks)->blocks,a_block_hash, sizeof (*a_block_hash), l_ret );
pthread_rwlock_unlock(& PVT(a_blocks)->rwlock);
return l_ret;
@@ -407,7 +408,8 @@ dap_chain_block_cache_t * dap_chain_block_cache_get_by_hash(dap_chain_cs_blocks_
dap_chain_block_cache_t * dap_chain_block_cache_get_by_number(dap_chain_cs_blocks_t * a_blocks, uint64_t a_block_number)
{
dap_chain_block_cache_t * l_ret = NULL;
- pthread_rwlock_rdlock(& PVT(a_blocks)->rwlock);
+ int err = pthread_rwlock_rdlock(& PVT(a_blocks)->rwlock);
+ assert(!err);
HASH_FIND_BYHASHVALUE(hh2, PVT(a_blocks)->blocks_num, &a_block_number, sizeof (a_block_number), a_block_number, l_ret);
pthread_rwlock_unlock(& PVT(a_blocks)->rwlock);
return l_ret;
@@ -1528,8 +1530,9 @@ static int s_callback_delete(dap_chain_t * a_chain)
{
s_callback_cs_blocks_purge(a_chain);
dap_chain_cs_blocks_t * l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
- pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
- if(l_blocks->callback_delete )
+ int err = pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
+ if (l_blocks->callback_delete)
l_blocks->callback_delete(l_blocks);
pthread_rwlock_unlock(&PVT(l_blocks)->rwlock);
pthread_rwlock_destroy(&PVT(l_blocks)->rwlock);
@@ -1557,7 +1560,8 @@ static int s_callback_cs_blocks_purge(dap_chain_t *a_chain)
DAP_DEL_Z(PVT(l_blocks)->forked_branches);
pthread_rwlock_unlock(&PVT(l_blocks)->forked_branches_rwlock);
- pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
+ int err = pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
dap_chain_block_cache_t *l_block = NULL, *l_block_tmp = NULL;
HASH_ITER(hh, PVT(l_blocks)->blocks, l_block, l_block_tmp) {
HASH_DEL(PVT(l_blocks)->blocks, l_block);
@@ -1806,7 +1810,8 @@ static dap_chain_atom_verify_res_t s_callback_atom_add(dap_chain_t * a_chain, da
}
debug_if(s_debug_more, L_DEBUG, "... new block %s", l_block_cache->block_hash_str);
- pthread_rwlock_wrlock(& PVT(l_blocks)->rwlock);
+ int err = pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
if (!l_block_cache->is_genesis) {
dap_chain_block_cache_t *l_last_block = HASH_LAST(PVT(l_blocks)->blocks);
if (l_last_block && dap_hash_fast_compare(&l_last_block->block_hash, &l_block_prev_hash)){
@@ -1887,6 +1892,7 @@ static dap_chain_atom_verify_res_t s_callback_atom_add(dap_chain_t * a_chain, da
uint8_t *l_generation_meta = dap_chain_block_meta_get(l_block, a_atom_size, DAP_CHAIN_BLOCK_META_GENERATION);
uint16_t l_generation = l_generation_meta ? *(uint16_t *)l_generation_meta : 0;
if (l_generation && a_chain->generation < l_generation) {
+ pthread_rwlock_unlock(&PVT(l_blocks)->rwlock);
dap_hash_fast_t *l_hardfork_decree_hash = (dap_hash_fast_t *)dap_chain_block_meta_get(l_block, a_atom_size, DAP_CHAIN_BLOCK_META_LINK);
if (!l_hardfork_decree_hash) {
log_it(L_ERROR, "Can't find hardfork decree hash in candidate block meta");
@@ -1902,6 +1908,7 @@ static dap_chain_atom_verify_res_t s_callback_atom_add(dap_chain_t * a_chain, da
log_it(L_ERROR, "Can't accept hardfork genesis block %s: error in hardfork data restoring", dap_hash_fast_to_str_static(a_atom_hash));
return ATOM_REJECT;
}
+ pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
}
HASH_ADD(hh, PVT(l_blocks)->blocks, block_hash, sizeof(l_block_cache->block_hash), l_block_cache);
HASH_ADD_BYHASHVALUE(hh2, PVT(l_blocks)->blocks_num, block_number, sizeof(l_block_cache->block_number), l_block_cache->block_number, l_block_cache);
@@ -1945,7 +1952,9 @@ static dap_chain_atom_verify_res_t s_callback_atom_add(dap_chain_t * a_chain, da
}
debug_if(s_debug_more, L_DEBUG, "... new block %s", l_block_cache->block_hash_str);
dap_chain_block_cache_t *l_prev_bcache = NULL, *l_tmp = NULL;
- pthread_rwlock_wrlock(& PVT(l_blocks)->rwlock); log_it(L_INFO, "New fork. Previous block hash %s, current block hash %s", dap_chain_hash_fast_to_str_static(&l_block_prev_hash),
+ int err = pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
+ log_it(L_INFO, "New fork. Previous block hash %s, current block hash %s", dap_chain_hash_fast_to_str_static(&l_block_prev_hash),
l_block_cache->block_hash_str);
HASH_FIND(hh, PVT(l_blocks)->blocks, &l_block_prev_hash, sizeof(dap_hash_fast_t), l_prev_bcache);
if (l_prev_bcache){
@@ -2103,8 +2112,9 @@ static dap_chain_atom_verify_res_t s_callback_atom_verify(dap_chain_t *a_chain,
if (l_bcache_last && dap_hash_fast_compare(&l_bcache_last->block_hash, &l_block_prev_hash))
ret = ATOM_ACCEPT;
else { // search block and previous block in forked branch
- pthread_rwlock_rdlock(& PVT(l_blocks)->rwlock);
- for (size_t i = 0; i < PVT(l_blocks)->forked_br_cnt; i++){
+ int err = pthread_rwlock_rdlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
+ for (size_t i = 0; i < PVT(l_blocks)->forked_br_cnt; i++) {
dap_chain_block_forked_branch_t *l_cur_branch = PVT(l_blocks)->forked_branches[i];
dap_chain_block_forked_branch_atoms_table_t *l_item = NULL;
// Check block already present in forked branch
@@ -2219,7 +2229,8 @@ static dap_chain_atom_ptr_t s_callback_atom_iter_get_by_num(dap_chain_atom_iter_
assert(a_atom_iter);
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_atom_iter->chain);
dap_chain_block_cache_t *l_block_cache = NULL;
- pthread_rwlock_rdlock(&PVT(l_blocks)->rwlock);
+ int err = pthread_rwlock_rdlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
for (l_block_cache = PVT(l_blocks)->blocks; l_block_cache; l_block_cache = l_block_cache->hh.next)
if (l_block_cache->block_number == a_atom_num)
break;
@@ -2426,7 +2437,8 @@ static dap_chain_atom_ptr_t s_callback_atom_iter_get(dap_chain_atom_iter_t *a_at
log_it(L_ERROR, "l_blocks_pvt is NULL");
return NULL;
}
- pthread_rwlock_rdlock(&l_blocks_pvt->rwlock);
+ int err = pthread_rwlock_rdlock(&l_blocks_pvt->rwlock);
+ assert(!err);
switch (a_operation) {
case DAP_CHAIN_ITER_OP_FIRST:
a_atom_iter->cur_item = l_blocks_pvt->blocks;
@@ -2598,7 +2610,8 @@ static dap_chain_block_t *s_new_block_move(dap_chain_cs_blocks_t *a_blocks, size
size_t l_ret_size = 0;
dap_chain_block_t *l_ret = NULL;
dap_chain_cs_blocks_pvt_t *l_blocks_pvt = PVT(a_blocks);
- pthread_rwlock_wrlock(&l_blocks_pvt->rwlock);
+ int err = pthread_rwlock_wrlock(&l_blocks_pvt->rwlock);
+ assert(!err);
if ( a_blocks->block_new ) {
l_ret = a_blocks->block_new;
l_ret_size = a_blocks->block_new_size;
@@ -2625,7 +2638,8 @@ static size_t s_callback_add_datums(dap_chain_t *a_chain, dap_chain_datum_t **a_
// dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
size_t l_datum_processed = 0;
- pthread_rwlock_wrlock(&l_blocks_pvt->rwlock);
+ int err = pthread_rwlock_wrlock(&l_blocks_pvt->rwlock);
+ assert(!err);
#ifdef DAP_TPS_TEST
log_it(L_TPS, "Start tps %zu datums add", a_datums_count);
#endif
@@ -2636,8 +2650,8 @@ static size_t s_callback_add_datums(dap_chain_t *a_chain, dap_chain_datum_t **a_
log_it(L_WARNING, "Empty datum"); /* How might it be? */
continue;
}
- if (l_blocks->block_new_size + l_datum_size > DAP_CHAIN_ATOM_MAX_SIZE) {
- log_it(L_DEBUG, "Maximum size exeeded, %zu > %d", l_blocks->block_new_size + l_datum_size, DAP_CHAIN_ATOM_MAX_SIZE);
+ if (l_blocks->block_new_size + l_datum_size > DAP_CHAIN_CANDIDATE_MAX_SIZE) {
+ log_it(L_DEBUG, "Maximum size exeeded, %zu > %d", l_blocks->block_new_size + l_datum_size, DAP_CHAIN_CANDIDATE_MAX_SIZE);
break;
}
if (!l_blocks->block_new) {
@@ -2684,7 +2698,8 @@ static dap_list_t *s_callback_get_atoms(dap_chain_t *a_chain, size_t a_count, si
{
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
dap_chain_cs_blocks_pvt_t *l_blocks_pvt = PVT(l_blocks);
- pthread_rwlock_rdlock(&PVT(l_blocks)->rwlock);
+ int err = pthread_rwlock_rdlock(&PVT(l_blocks)->rwlock);
+ assert(!err);
if (!l_blocks_pvt->blocks) {
pthread_rwlock_unlock(&PVT(l_blocks)->rwlock);
return NULL;
diff --git a/modules/type/blocks/include/dap_chain_block.h b/modules/type/blocks/include/dap_chain_block.h
index c21e531057a10b39334f2337f4cd5476d05d3fdb..755a6aaf4cdb5ef89830b216de492bb031462dce 100644
--- a/modules/type/blocks/include/dap_chain_block.h
+++ b/modules/type/blocks/include/dap_chain_block.h
@@ -24,12 +24,18 @@
#include "dap_common.h"
#include "dap_time.h"
#include "dap_hash.h"
+#include "dap_chain.h"
#include "dap_chain_common.h"
#include "dap_chain_datum.h"
#define DAP_CHAIN_BLOCK_SIGNATURE 0xDA05BF8E
#define DAP_CHAIN_BLOCK_ID_SIZE 4
+#define DAP_CHAIN_CANDIDATE_SIGNS_MAX_SIZE (256 * 1024)
+#if (DAP_CHAIN_CANDIDATE_SIGNS_MAX_SIZE >= DAP_CHAIN_ATOM_MAX_SIZE)
+#error DAP_CHAIN_ATOM_MAX_SIZE should be greater than DAP_CHAIN_CANDIDATE_SIGNS_MAX_SIZE
+#endif
+#define DAP_CHAIN_CANDIDATE_MAX_SIZE (DAP_CHAIN_ATOM_MAX_SIZE - DAP_CHAIN_CANDIDATE_SIGNS_MAX_SIZE)
typedef union dap_chain_block_typeid{
uint8_t data[DAP_CHAIN_BLOCK_ID_SIZE];