diff --git a/dap-sdk b/dap-sdk
index 85b0a265180fc0d3a4d34ba6c7f3b5fee82f173d..6433d931b917ceb7b71967817acc03c454dabb30 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 85b0a265180fc0d3a4d34ba6c7f3b5fee82f173d
+Subproject commit 6433d931b917ceb7b71967817acc03c454dabb30
diff --git a/modules/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index e4b44b2a987c1c20cbcbb2bb19e45f18512ff370..5d10ba584ffbc32504e9d0f4650ba5155edbbc99 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -199,7 +199,7 @@ typedef struct dap_chain {
// Iterator callbacks
dap_chain_datum_callback_iter_create_t callback_datum_iter_create;
dap_chain_datum_callback_iter_get_first_t callback_datum_iter_get_first;
- dap_chain_datum_callback_iter_get_first_t callback_datum_iter_get_next;
+ dap_chain_datum_callback_iter_get_next_t callback_datum_iter_get_next;
dap_chain_datum_callback_iter_delete_t callback_datum_iter_delete;
dap_list_t *atom_notifiers;
diff --git a/modules/channel/chain-net/dap_stream_ch_chain_net.c b/modules/channel/chain-net/dap_stream_ch_chain_net.c
index 661b934c1dcca37cfbe5841510c8ffa6ee1c76fe..3ebf2d09cd2e6658c796a69cadf906a32a694d09 100644
--- a/modules/channel/chain-net/dap_stream_ch_chain_net.c
+++ b/modules/channel/chain-net/dap_stream_ch_chain_net.c
@@ -188,13 +188,19 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void* a_arg)
l_ch_chain_net_pkt->hdr.net_id,NULL, 0);
dap_stream_ch_set_ready_to_write_unsafe(a_ch, true);
break;
- // receive pong request -> send nothing
+
+ // received pong request -> send nothing
case DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_PONG:
//log_it(L_INFO, "Get CHAIN_CH_NET_PKT_TYPE_PONG");
dap_stream_ch_set_ready_to_write_unsafe(a_ch, false);
break;
case DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY_REQUEST:{
+ if (l_ch_chain_net_pkt->hdr.data_size != DAP_CHAIN_NET_CH_VALIDATOR_READY_REQUEST_SIZE) {
+ log_it(L_WARNING, "Invalid VALIDATOR_READY_REQUEST size %hu, expected %u", l_ch_chain_net_pkt->hdr.data_size,
+ DAP_CHAIN_NET_CH_VALIDATOR_READY_REQUEST_SIZE);
+ return false;
+ }
log_it(L_INFO, "Get CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY_REQUEST");
dap_chain_net_t * l_net = dap_chain_net_by_id( l_ch_chain_net_pkt->hdr.net_id );
if ( l_net == NULL){
@@ -203,83 +209,77 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void* a_arg)
l_ch_chain_net_pkt->hdr.net_id, l_err_str,sizeof (l_err_str));
dap_stream_ch_set_ready_to_write_unsafe(a_ch, true);
log_it(L_ERROR, "Invalid net id in packet");
- } else {
- dap_list_t * l_orders = NULL;
- dap_enc_key_t *l_enc_key_pvt = NULL;
- dap_chain_t *l_chain = NULL;
- DL_FOREACH(l_net->pub.chains, l_chain)
- if (!dap_strcmp(dap_chain_get_cs_type(l_chain), "esbocs")) {
- l_enc_key_pvt = dap_chain_esbocs_get_sign_key(l_chain);
- if (l_enc_key_pvt)
- break;
- }
- dap_sign_t *l_sign = NULL;
- size_t sign_s = 0;
- size_t l_orders_num = 0;
- dap_chain_ch_validator_test_t *send = NULL;
- dap_chain_net_srv_price_unit_uid_t l_price_unit = { { 0 } };
- dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_STAKE_POS_DELEGATE_ID };
- uint256_t l_price_min = {};
- uint256_t l_price_max = {};
- uint8_t flags = 0;
- dap_chain_node_addr_t l_cur_node_addr = {
- .uint64 = dap_chain_net_get_cur_addr_int(l_net)
- };
-
- if (l_enc_key_pvt) {
- flags = flags | F_CERT;//faund sert
- l_sign = dap_sign_create(l_enc_key_pvt, (uint8_t*)l_ch_chain_net_pkt->data,
- l_ch_chain_net_pkt->hdr.data_size, 0);
- if(l_sign)
- {
- sign_s = dap_sign_get_size(l_sign);
- flags = flags | D_SIGN;//data signed
- }
- else
- flags = flags & ~D_SIGN;//data doesn't sign
+ break;
+ }
+ dap_list_t * l_orders = NULL;
+ dap_enc_key_t *l_enc_key_pvt = NULL;
+ dap_chain_t *l_chain = NULL;
+ DL_FOREACH(l_net->pub.chains, l_chain)
+ if (!dap_strcmp(dap_chain_get_cs_type(l_chain), "esbocs")) {
+ l_enc_key_pvt = dap_chain_esbocs_get_sign_key(l_chain);
+ if (l_enc_key_pvt)
+ break;
}
- else
- flags = flags & ~F_CERT;//Specified certificate not found
+ dap_sign_t *l_sign = NULL;
+ size_t sign_s = 0;
+ size_t l_orders_num = 0;
+ dap_chain_ch_validator_test_t *send = NULL;
+ dap_chain_net_srv_price_unit_uid_t l_price_unit = { { 0 } };
+ dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_STAKE_POS_DELEGATE_ID };
+ uint256_t l_price_min = {};
+ uint256_t l_price_max = {};
+ uint8_t flags = 0;
+
+ if (l_enc_key_pvt) {
+ flags = flags | F_CERT;//faund sert
+ l_sign = dap_sign_create(l_enc_key_pvt, (uint8_t*)l_ch_chain_net_pkt->data, l_ch_chain_net_pkt->hdr.data_size, 0);
+ if (l_sign) {
+ sign_s = dap_sign_get_size(l_sign);
+ flags = flags | D_SIGN;//data signed
+ } else
+ flags = flags & ~D_SIGN;//data doesn't sign
+ }
+ else
+ flags = flags & ~F_CERT;//Specified certificate not found
- send = DAP_NEW_Z_SIZE(dap_chain_ch_validator_test_t, sizeof(dap_chain_ch_validator_test_t) + sign_s);
+ send = DAP_NEW_Z_SIZE(dap_chain_ch_validator_test_t, sizeof(dap_chain_ch_validator_test_t) + sign_s);
#ifdef DAP_VERSION
- strncpy((char *)send->header.version, (char *)DAP_VERSION, sizeof(send->header.version));
+ strncpy((char *)send->header.version, (char *)DAP_VERSION, sizeof(send->header.version));
#endif
- send->header.sign_size = sign_s;
- //strncpy(send->header.data,(uint8_t*)l_ch_chain_net_pkt->data,10);
- flags = (l_net->pub.mempool_autoproc) ? flags | A_PROC : flags & ~A_PROC;
+ send->header.sign_size = sign_s;
+ //strncpy(send->header.data,(uint8_t*)l_ch_chain_net_pkt->data,10);
+ flags = (l_net->pub.mempool_autoproc) ? flags | A_PROC : flags & ~A_PROC;
- if (dap_chain_net_srv_order_find_all_by(l_net,SERV_DIR_UNDEFINED,l_uid,
- l_price_unit,NULL,l_price_min,l_price_max,&l_orders,&l_orders_num)==0){
- for (dap_list_t *l_temp = l_orders;l_temp; l_temp = l_orders->next){
- dap_chain_net_srv_order_t *l_order =(dap_chain_net_srv_order_t *) l_temp->data;
- if(l_order->node_addr.uint64 == l_cur_node_addr.uint64)
- {
- flags = flags | F_ORDR;
- break;
- }
+ if (dap_chain_net_srv_order_find_all_by(l_net,SERV_DIR_UNDEFINED,l_uid,
+ l_price_unit,NULL,l_price_min,l_price_max,&l_orders,&l_orders_num)==0){
+ for (dap_list_t *l_temp = l_orders;l_temp; l_temp = l_orders->next){
+ dap_chain_net_srv_order_t *l_order =(dap_chain_net_srv_order_t *) l_temp->data;
+ if(l_order->node_addr.uint64 == g_node_addr.uint64)
+ {
+ flags = flags | F_ORDR;
+ break;
}
- dap_list_free_full(l_orders, NULL);
}
- bool auto_online = dap_config_get_item_bool_default( g_config, "general", "auto_online", false );
- bool auto_update = false;
- if((system("systemctl status cellframe-updater.service") == 768) && (system("systemctl status cellframe-updater.timer") == 0))
- auto_update = true;
- else
- auto_update = false;
- flags = auto_online ? flags | A_ONLN : flags & ~A_ONLN;
- flags = auto_update ? flags | A_UPDT : flags & ~A_UPDT;
- send->header.flags = flags;
- //add sign
- if(sign_s)
- memcpy(send->sign,l_sign,sign_s);
- dap_stream_ch_chain_net_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY ,
- l_ch_chain_net_pkt->hdr.net_id, send, sizeof(dap_chain_ch_validator_test_t) + sign_s);
- dap_stream_ch_set_ready_to_write_unsafe(a_ch, true);
- if(l_sign)
- DAP_DELETE(l_sign);
- DAP_DELETE(send);
+ dap_list_free_full(l_orders, NULL);
}
+ bool auto_online = dap_config_get_item_bool_default( g_config, "general", "auto_online", false );
+ bool auto_update = false;
+ if((system("systemctl status cellframe-updater.service") == 768) && (system("systemctl status cellframe-updater.timer") == 0))
+ auto_update = true;
+ else
+ auto_update = false;
+ flags = auto_online ? flags | A_ONLN : flags & ~A_ONLN;
+ flags = auto_update ? flags | A_UPDT : flags & ~A_UPDT;
+ send->header.flags = flags;
+ //add sign
+ if(sign_s)
+ memcpy(send->sign,l_sign,sign_s);
+ dap_stream_ch_chain_net_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY ,
+ l_ch_chain_net_pkt->hdr.net_id, send, sizeof(dap_chain_ch_validator_test_t) + sign_s);
+ dap_stream_ch_set_ready_to_write_unsafe(a_ch, true);
+ if(l_sign)
+ DAP_DELETE(l_sign);
+ DAP_DELETE(send);
} break;
case DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY:{
diff --git a/modules/channel/chain-net/include/dap_stream_ch_chain_net_pkt.h b/modules/channel/chain-net/include/dap_stream_ch_chain_net_pkt.h
index d6a9573c7d7d4b5c7d26435e87c4ec2346c57bc7..983a290cdc14bf03650689c1ee3e86b2a78a162e 100644
--- a/modules/channel/chain-net/include/dap_stream_ch_chain_net_pkt.h
+++ b/modules/channel/chain-net/include/dap_stream_ch_chain_net_pkt.h
@@ -45,6 +45,8 @@
#define DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_ERROR 0xff
+#define DAP_CHAIN_NET_CH_VALIDATOR_READY_REQUEST_SIZE 1024
+
typedef struct stream_ch_chain_net_pkt_hdr {
uint8_t version;
byte_t padding;
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index e21e4c20a087d9845b0e999412e80679079435eb..f70b98db1c44f4d8e48f4e285803295974fdf862 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -47,11 +47,8 @@
*/
dap_chain_datum_t *dap_chain_datum_create(uint16_t a_type_id, const void *a_data, size_t a_data_size)
{
- dap_chain_datum_t *l_datum = DAP_NEW_Z_SIZE(dap_chain_datum_t, sizeof(l_datum->header) + a_data_size);
- if(!l_datum) {
- log_it(L_CRITICAL, "%s", g_error_memory_alloc);
- return NULL;
- }
+ dap_chain_datum_t *l_datum = NULL;
+ DAP_NEW_Z_SIZE_RET_VAL(l_datum, dap_chain_datum_t, sizeof(l_datum->header) + a_data_size, NULL, NULL);
*l_datum = (dap_chain_datum_t) {
.header = {
.version_id = DAP_CHAIN_DATUM_VERSION,
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 529de839c5917920856519cebcf040fbf126f455..114575ca1bb6a8c4bb14b122ce54fb9436280d87 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -73,13 +73,18 @@ dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t *a_token, size_
return (dap_tsd_t*)a_token->data_n_tsd;
}
-dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial, size_t *a_token_size) {
+dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial, size_t *a_token_size)
+{
dap_chain_datum_token_old_t *l_token_old = (dap_chain_datum_token_old_t*)a_token_serial;
size_t l_token_data_n_tsd_size = *a_token_size - sizeof(dap_chain_datum_token_old_t);
size_t l_token_size = l_token_data_n_tsd_size + sizeof(dap_chain_datum_token_t);
switch (((dap_chain_datum_token_t*)a_token_serial)->type) {
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
dap_chain_datum_token_t *l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ if (!l_token) {
+ log_it(L_CRITICAL, g_error_memory_alloc);
+ return NULL;
+ }
*l_token = (dap_chain_datum_token_t) {
.type = DAP_CHAIN_DATUM_TOKEN_TYPE_DECL,
.version = 1,
@@ -96,6 +101,10 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial
}
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL: {
dap_chain_datum_token_t *l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ if (!l_token) {
+ log_it(L_CRITICAL, g_error_memory_alloc);
+ return NULL;
+ }
*l_token = (dap_chain_datum_token_t) {
.type = DAP_CHAIN_DATUM_TOKEN_TYPE_DECL,
.version = 1,
@@ -114,6 +123,10 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial
}
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE: {
dap_chain_datum_token_t *l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ if (!l_token) {
+ log_it(L_CRITICAL, g_error_memory_alloc);
+ return NULL;
+ }
*l_token = (dap_chain_datum_token_t) {
.type = DAP_CHAIN_DATUM_TOKEN_TYPE_UPDATE,
.version = 1,
@@ -132,6 +145,10 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial
}
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_NATIVE_DECL: {
dap_chain_datum_token_t *l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ if (!l_token) {
+ log_it(L_CRITICAL, g_error_memory_alloc);
+ return NULL;
+ }
*l_token = (dap_chain_datum_token_t) {
.type = DAP_CHAIN_DATUM_TOKEN_TYPE_DECL,
.version = 1,
@@ -150,6 +167,10 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial
}
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_NATIVE_UPDATE: {
dap_chain_datum_token_t *l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ if (!l_token) {
+ log_it(L_CRITICAL, g_error_memory_alloc);
+ return NULL;
+ }
*l_token = (dap_chain_datum_token_t) {
.type = DAP_CHAIN_DATUM_TOKEN_TYPE_UPDATE,
.version = 1,
@@ -168,6 +189,10 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial
}
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC: {
dap_chain_datum_token_t *l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ if (!l_token) {
+ log_it(L_CRITICAL, g_error_memory_alloc);
+ return NULL;
+ }
*l_token = (dap_chain_datum_token_t) {
.type = DAP_CHAIN_DATUM_TOKEN_TYPE_DECL,
.version = 1,
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 01511bfd93ec2efaea5a476736a7e8b468535a9e..e8069c9cb6c787d9ffc7d74d25243ad959e9b05f 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -296,40 +296,36 @@ int dap_chain_datum_tx_add_sign_item(dap_chain_datum_tx_t **a_tx, dap_enc_key_t
*
* return 1 Ok, 0 Invalid signature, -1 Not found signature or other Error
*/
-int dap_chain_datum_tx_verify_sign(dap_chain_datum_tx_t *tx)
+int dap_chain_datum_tx_verify_sign(dap_chain_datum_tx_t *a_tx)
{
- int ret = -1;
- if(!tx)
- return -2;
- uint32_t tx_items_pos = 0, tx_items_size = tx->header.tx_items_size;
+ dap_return_val_if_pass(!a_tx, -1);
+ int l_ret = 0;
+ uint32_t tx_items_pos = 0, tx_items_size = a_tx->header.tx_items_size;
while(tx_items_pos < tx_items_size) {
- uint8_t *item = tx->tx_items + tx_items_pos;
+ uint8_t *item = a_tx->tx_items + tx_items_pos;
size_t l_item_tx_size = dap_chain_datum_item_tx_get_size(item);
if(!l_item_tx_size || l_item_tx_size > tx_items_size)
- return -3;
+ return -2;
if(dap_chain_datum_tx_item_get_type(item) == TX_ITEM_TYPE_SIG) {
dap_chain_tx_sig_t *l_item_tx_sig = (dap_chain_tx_sig_t*) item;
dap_sign_t *l_sign = (dap_sign_t*) l_item_tx_sig->sig;
if ( ( l_sign->header.sign_size + l_sign->header.sign_pkey_size +sizeof (l_sign->header) )
> l_item_tx_size ){
log_it(L_WARNING,"Incorrect signature's header, possible corrupted data");
- return -4;
+ return -3;
}
- if (dap_sign_verify_all(l_sign, tx_items_size, tx->tx_items, tx_items_pos)) {
+ if ((l_ret = dap_sign_verify_all(l_sign, tx_items_size, a_tx->tx_items, tx_items_pos))) {
// invalid signature
- ret = 0;
tx_items_pos += l_item_tx_size;
break;
}
- // signature verify successfully
- ret = 1;
}
// sign item or items must be at the end, therefore ret will be changed later anyway
else
- ret = -4;
+ l_ret = -4;
// go to text item
tx_items_pos += l_item_tx_size;
}
assert(tx_items_pos == tx_items_size);
- return ret;
+ return l_ret;
}
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 19b1f2a926e4611a18250e599ef7a90259058e36..91d06c0e68a9105616d48f1b29fcddac427b7016 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -88,10 +88,7 @@ int dap_datum_mempool_init(void)
*/
char *dap_chain_mempool_datum_add(const dap_chain_datum_t *a_datum, dap_chain_t *a_chain, const char *a_hash_out_type)
{
- if( a_datum == NULL){
- log_it(L_ERROR, "NULL datum trying to add in mempool");
- return NULL;
- }
+ dap_return_val_if_pass(!a_datum, NULL);
dap_chain_hash_fast_t l_key_hash;
dap_hash_fast(a_datum->data, a_datum->header.data_size, &l_key_hash);
@@ -149,9 +146,8 @@ char *dap_chain_mempool_tx_create(dap_chain_t * a_chain, dap_enc_key_t *a_key_fr
uint256_t a_value, uint256_t a_value_fee, const char *a_hash_out_type)
{
// check valid param
- if(!a_chain | !a_key_from || ! a_addr_from || !a_key_from->priv_key_data || !a_key_from->priv_key_data_size ||
- dap_chain_addr_check_sum(a_addr_from) || (a_addr_to && dap_chain_addr_check_sum(a_addr_to)) || IS_ZERO_256(a_value))
- return NULL;
+ dap_return_val_if_pass(!a_chain | !a_key_from || !a_addr_from || !a_key_from->priv_key_data || !a_key_from->priv_key_data_size ||
+ dap_chain_addr_check_sum(a_addr_from) || (a_addr_to && dap_chain_addr_check_sum(a_addr_to)) || IS_ZERO_256(a_value), NULL);
const char *l_native_ticker = dap_chain_net_by_id(a_chain->net_id)->pub.native_ticker;
bool l_single_channel = !dap_strcmp(a_token_ticker, l_native_ticker);
@@ -577,7 +573,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
return -2;
}
- dap_global_db_obj_t * l_objs = DAP_NEW_Z_SIZE(dap_global_db_obj_t, (a_tx_num + 1) * sizeof (dap_global_db_obj_t));
+ dap_global_db_obj_t * l_objs = DAP_NEW_Z_SIZE(dap_global_db_obj_t, a_tx_num * sizeof (dap_global_db_obj_t));
uint256_t l_net_fee = {}, l_total_fee = {};
dap_chain_addr_t l_addr_fee = {};
bool l_net_fee_used = dap_chain_net_tx_get_fee(a_chain->net_id, &l_net_fee, &l_addr_fee);
@@ -592,13 +588,13 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
log_it(L_DEBUG, "Create %"DAP_UINT64_FORMAT_U" transactions, summary %s", a_tx_num, l_balance);
dap_ledger_t *l_ledger = dap_chain_net_by_id(a_chain->net_id)->pub.ledger;
dap_list_t *l_list_used_out = dap_ledger_get_list_tx_outs_with_val(l_ledger, a_token_ticker,
- a_addr_from, l_value_need, &l_value_transfer);
+ a_addr_from, l_value_need, &l_value_transfer);
if (!l_list_used_out) {
log_it(L_WARNING,"Not enough funds to transfer");
DAP_DELETE(l_objs);
return -2;
}
-
+
dap_chain_hash_fast_t l_tx_new_hash = {0};
for (size_t i=0; i< a_tx_num ; i++){
log_it(L_DEBUG, "Prepare tx %zu",i);
@@ -635,6 +631,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
"Not enough values on output to produce enough inputs: %s when need ", l_balance);
strcat(l_log_str, dap_uint256_to_char(l_single_val, NULL));
log_it(L_ERROR, "%s", l_log_str);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
return -5;
}
@@ -645,6 +642,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
SUM_256_256(l_value_pack, a_value, &l_value_pack);
else {
dap_chain_datum_tx_delete(l_tx_new);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
return -3;
}
@@ -654,6 +652,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
SUM_256_256(l_value_pack, l_net_fee, &l_value_pack);
else {
dap_chain_datum_tx_delete(l_tx_new);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
return -3;
}
@@ -664,6 +663,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
SUM_256_256(l_value_pack, a_value_fee, &l_value_pack);
else {
dap_chain_datum_tx_delete(l_tx_new);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
return -3;
}
@@ -673,6 +673,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
if (!IS_ZERO_256(l_value_back)) {
if(dap_chain_datum_tx_add_out_item(&l_tx_new, a_addr_from, l_value_back) != 1) {
dap_chain_datum_tx_delete(l_tx_new);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
return -3;
}
@@ -681,6 +682,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
// add 'sign' items
if(dap_chain_datum_tx_add_sign_item(&l_tx_new, a_key_from) != 1) {
dap_chain_datum_tx_delete(l_tx_new);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
return -4;
}
@@ -713,8 +715,8 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
dap_chain_tx_used_out_item_t *l_item_back = DAP_NEW_Z(dap_chain_tx_used_out_item_t);
if (!l_item_back) {
log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+ dap_list_free_full(l_list_used_out, NULL);
DAP_DELETE(l_objs);
- dap_list_free(l_list_out_items);
return -6;
}
*l_item_back = (dap_chain_tx_used_out_item_t) {
@@ -729,27 +731,25 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
l_list_tmp = l_list_tmp->next;
l_out_idx_tmp++;
}
- dap_list_free(l_list_out_items);
}
SUBTRACT_256_256(l_value_transfer, l_value_pack, &l_value_transfer);
// Now produce datum
dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx_new, l_tx_size);
-
- dap_chain_datum_tx_delete(l_tx_new);
- //dap_ledger_tx_add( a_chain->ledger, l_tx);
-
+ //dap_global_db_set_sync(l_gdb_group, l_key_str, a_datum, dap_chain_datum_size(l_datum), false);
l_objs[i].key = dap_chain_hash_fast_to_str_new(&l_tx_new_hash);
l_objs[i].value = (uint8_t *)l_datum;
l_objs[i].value_len = dap_chain_datum_size(l_datum);
+ l_objs[i].timestamp = dap_nanotime_now();
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 );
+ l_objs[i].key ? l_objs[i].key :"NULL" , l_objs[i].value_len );
+ dap_chain_datum_tx_delete(l_tx_new);
+
}
dap_list_free_full(l_list_used_out, 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);
+ DAP_DEL_Z(l_gdb_group);
return 0;
}
@@ -770,7 +770,6 @@ static bool s_tx_create_massive_gdb_save_callback(dap_global_db_instance_t *a_db
const size_t a_values_total, const size_t a_values_count,
dap_global_db_obj_t *a_values, void *a_arg)
{
- DAP_DELETE(a_values);
if(!a_rc) {
log_it(L_NOTICE, "%zu transaction are placed in mempool", a_values_total);
return true;
@@ -1005,7 +1004,6 @@ char *dap_chain_mempool_tx_create_cond(dap_chain_net_t *a_net,
log_it( L_ERROR, "Can't add sign output");
return NULL;
}
-
size_t l_tx_size = dap_chain_datum_tx_get_size( l_tx );
dap_chain_datum_t *l_datum = dap_chain_datum_create( DAP_CHAIN_DATUM_TX, l_tx, l_tx_size );
dap_chain_datum_tx_delete(l_tx);
diff --git a/modules/net/dap_chain_ledger.c b/modules/net/dap_chain_ledger.c
index 40ccfc136e1dfa1beffbe2e63f8a36089f47c19a..3b2ce8bc1086a03751a79dd8b32764601053ef35 100644
--- a/modules/net/dap_chain_ledger.c
+++ b/modules/net/dap_chain_ledger.c
@@ -336,12 +336,6 @@ typedef struct dap_ledger_private {
dap_list_t *tx_add_notifiers;
dap_ledger_cache_tx_check_callback_t cache_tx_check_callback;
- // TPS section
- dap_timerfd_t *tps_timer;
- struct timespec tps_start_time;
- struct timespec tps_current_time;
- struct timespec tps_end_time;
- size_t tps_count;
// Threshold fee
dap_interval_timer_t threshold_txs_free_timer, threshold_emissions_free_timer;
} dap_ledger_private_t;
@@ -363,7 +357,6 @@ static void s_threshold_emission_free(dap_ledger_t *a_ledger);
static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_ledger_token_item_t *a_token_item , dap_chain_datum_token_t * a_token, size_t a_token_size);
static int s_tsd_sign_apply(dap_ledger_t *a_ledger, dap_ledger_token_item_t *a_token_item , dap_chain_datum_token_t *a_token, size_t a_token_size);
static int s_ledger_permissions_check(dap_ledger_token_item_t * a_token_item, uint16_t a_permission_id, const void * a_data,size_t a_data_size );
-static bool s_ledger_tps_callback(void *a_arg);
static int s_sort_ledger_tx_item(dap_ledger_tx_item_t* a, dap_ledger_tx_item_t* b);
static size_t s_threshold_emissions_max = 1000;
@@ -3887,7 +3880,7 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger,
int l_prev_tx_count = 0;
// 1. Verify signature in current transaction
- if (!a_from_threshold && dap_chain_datum_tx_verify_sign(a_tx) != 1)
+ if (!a_from_threshold && dap_chain_datum_tx_verify_sign(a_tx))
return DAP_LEDGER_TX_CHECK_INVALID_TX_SIGN;
// ----------------------------------------------------------------
@@ -4719,8 +4712,7 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger,
*/
int dap_ledger_tx_add_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, size_t a_datum_size, dap_hash_fast_t *a_datum_hash)
{
- if (!a_tx)
- return DAP_LEDGER_TX_CHECK_NULL_TX;
+ dap_return_val_if_pass(!a_tx, DAP_LEDGER_TX_CHECK_NULL_TX);
size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
if (l_tx_size != a_datum_size) {
@@ -4731,13 +4723,11 @@ int dap_ledger_tx_add_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
int l_ret_check = dap_ledger_tx_cache_check(a_ledger, a_tx, a_datum_hash,
false, NULL, NULL, NULL, NULL, NULL, false);
if(s_debug_more) {
- char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_chain_hash_fast_to_str(a_datum_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
if (l_ret_check)
log_it(L_NOTICE, "Ledger TX adding check not passed for TX %s: error %s",
- l_tx_hash_str, dap_ledger_tx_check_err_str(l_ret_check));
+ dap_chain_hash_fast_to_str_static(a_datum_hash), dap_ledger_tx_check_err_str(l_ret_check));
else
- log_it(L_INFO, "Ledger TX adding check passed for TX %s", l_tx_hash_str);
+ log_it(L_INFO, "Ledger TX adding check passed for TX %s", dap_chain_hash_fast_to_str_static(a_datum_hash));
}
return l_ret_check;
@@ -4774,11 +4764,6 @@ static int s_sort_ledger_tx_item(dap_ledger_tx_item_t* a, dap_ledger_tx_item_t*
a->tx->header.ts_created < b->tx->header.ts_created ? -1 : 1;
}
-void dap_ledger_set_tps_start_time(dap_ledger_t *a_ledger)
-{
- clock_gettime(CLOCK_REALTIME, &PVT(a_ledger)->tps_start_time);
-}
-
/**
* @brief Add new transaction to the cache list
* @param a_ledger
@@ -4800,18 +4785,6 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
dap_ledger_tx_item_t *l_item_tmp = NULL;
char *l_main_token_ticker = NULL;
- if (!l_ledger_pvt->tps_timer) {
-#ifndef DAP_TPS_TEST
- dap_ledger_set_tps_start_time(a_ledger);
-#endif
- l_ledger_pvt->tps_current_time.tv_sec = l_ledger_pvt->tps_start_time.tv_sec;
- l_ledger_pvt->tps_current_time.tv_nsec = l_ledger_pvt->tps_start_time.tv_nsec;
- l_ledger_pvt->tps_count = 0;
- if (dap_events_workers_init_status())
- l_ledger_pvt->tps_timer = dap_timerfd_start(500, s_ledger_tps_callback, l_ledger_pvt);
- else
- l_ledger_pvt->tps_timer = NULL;
- }
bool l_from_threshold = a_from_threshold;
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));
@@ -5142,9 +5115,6 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
l_notify->callback(a_ledger, a_tx, a_tx_hash, l_notify->arg, DAP_LEDGER_NOTIFY_OPCODE_ADDED);
}
}
- // Count TPS
- clock_gettime(CLOCK_REALTIME, &l_ledger_pvt->tps_end_time);
- l_ledger_pvt->tps_count++;
if (PVT(a_ledger)->cached) {
// Add it to cache
size_t l_tx_cache_sz = l_tx_size + sizeof(l_tx_item->cache_data);
@@ -5473,20 +5443,6 @@ FIN:
return l_ret;
}
-
-static bool s_ledger_tps_callback(void *a_arg)
-{
- dap_ledger_private_t *l_ledger_pvt = (dap_ledger_private_t *)a_arg;
- if (l_ledger_pvt->tps_current_time.tv_sec != l_ledger_pvt->tps_end_time.tv_sec ||
- l_ledger_pvt->tps_current_time.tv_nsec != l_ledger_pvt->tps_end_time.tv_nsec) {
- l_ledger_pvt->tps_current_time.tv_sec = l_ledger_pvt->tps_end_time.tv_sec;
- l_ledger_pvt->tps_current_time.tv_nsec = l_ledger_pvt->tps_end_time.tv_nsec;
- return true;
- }
- l_ledger_pvt->tps_timer = NULL;
- return false;
-}
-
int dap_ledger_tx_load(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_hash_fast_t *a_tx_hash)
{
#ifndef DAP_LEDGER_TEST
@@ -5660,44 +5616,26 @@ uint64_t dap_ledger_count_from_to(dap_ledger_t * a_ledger, dap_time_t a_ts_from,
pthread_rwlock_rdlock(&l_ledger_pvt->ledger_rwlock);
if ( a_ts_from && a_ts_to) {
HASH_ITER(hh, l_ledger_pvt->ledger_items , l_iter_current, l_item_tmp){
- if ( l_iter_current->tx->header.ts_created >= a_ts_from && l_iter_current->cache_data.ts_created <= a_ts_to )
- l_ret++;
+ if ( l_iter_current->tx->header.ts_created >= a_ts_from && l_iter_current->tx->header.ts_created <= a_ts_to )
+ l_ret++;
}
} else if ( a_ts_to ){
HASH_ITER(hh, l_ledger_pvt->ledger_items , l_iter_current, l_item_tmp){
if ( l_iter_current->tx->header.ts_created <= a_ts_to )
- l_ret++;
+ l_ret++;
}
} else if ( a_ts_from ){
HASH_ITER(hh, l_ledger_pvt->ledger_items , l_iter_current, l_item_tmp){
if ( l_iter_current->tx->header.ts_created >= a_ts_from )
- l_ret++;
- }
- }else {
- HASH_ITER(hh, l_ledger_pvt->ledger_items , l_iter_current, l_item_tmp){
- l_ret++;
+ l_ret++;
}
+ } else {
+ l_ret = HASH_COUNT(l_ledger_pvt->ledger_items);
}
-
pthread_rwlock_unlock(&l_ledger_pvt->ledger_rwlock);
return l_ret;
}
-size_t dap_ledger_count_tps(dap_ledger_t *a_ledger, struct timespec *a_ts_from, struct timespec *a_ts_to)
-{
- if (!a_ledger)
- return 0;
- dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- if (a_ts_from) {
- a_ts_from->tv_sec = l_ledger_pvt->tps_start_time.tv_sec;
- a_ts_from->tv_nsec = l_ledger_pvt->tps_start_time.tv_nsec;
- }
- if (a_ts_to) {
- a_ts_to->tv_sec = l_ledger_pvt->tps_end_time.tv_sec;
- a_ts_to->tv_nsec = l_ledger_pvt->tps_end_time.tv_nsec;
- }
- return l_ledger_pvt->tps_count;
-}
/**
* Check whether used 'out' items
@@ -5780,7 +5718,7 @@ uint256_t dap_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_chain_a
if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
// if 'out' item not used & transaction is valid
if(!s_ledger_tx_hash_is_used_out_item(l_iter_current, l_out_idx_tmp, NULL) &&
- dap_chain_datum_tx_verify_sign(l_cur_tx)) {
+ !dap_chain_datum_tx_verify_sign(l_cur_tx)) {
uint256_t l_add = dap_chain_uint256_from(l_tx_out->header.value);
SUM_256_256(balance, l_add, &balance);
}
@@ -5796,7 +5734,7 @@ uint256_t dap_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_chain_a
if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
// if 'out' item not used & transaction is valid
if(!s_ledger_tx_hash_is_used_out_item(l_iter_current, l_out_idx_tmp, NULL) &&
- dap_chain_datum_tx_verify_sign(l_cur_tx)) {
+ !dap_chain_datum_tx_verify_sign(l_cur_tx)) {
SUM_256_256(balance, l_tx_out->header.value, &balance);
}
}
@@ -5811,7 +5749,7 @@ uint256_t dap_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_chain_a
if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
// if 'out' item not used & transaction is valid
if(!s_ledger_tx_hash_is_used_out_item(l_iter_current, l_out_idx_tmp, NULL) &&
- dap_chain_datum_tx_verify_sign(l_cur_tx)) {
+ !dap_chain_datum_tx_verify_sign(l_cur_tx)) {
SUM_256_256(balance, l_tx_out->header.value, &balance);
}
}
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index d4d21553ed89149a7aafe38aea13f48a031589fd..ab659d337739a8be2e142fd3e4023b59d0fc4a0d 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -186,6 +186,7 @@ typedef struct dap_chain_net_pvt{
struct block_reward *rewards;
dap_chain_net_decree_t *decree;
decree_table_t *decrees;
+ anchor_table_t *anchors;
} dap_chain_net_pvt_t;
typedef struct dap_chain_net_item{
@@ -383,12 +384,10 @@ int dap_chain_net_state_go_to(dap_chain_net_t *a_net, dap_chain_net_state_t a_ne
dap_link_manager_set_net_condition(a_net->pub.id.uint64, true);
for (uint16_t i = 0; i < PVT(a_net)->permanent_links_count; ++i) {
dap_link_info_t *l_permalink_info = PVT(a_net)->permanent_links[i];
- if (dap_link_manager_link_create(&l_permalink_info->node_addr, a_net->pub.id.uint64)) {
+ if (dap_chain_net_link_add(a_net, &l_permalink_info->node_addr, l_permalink_info->uplink_addr, l_permalink_info->uplink_port)) {
log_it(L_ERROR, "Can't create permanent link to addr " NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_permalink_info->node_addr));
continue;
}
- if (l_permalink_info->uplink_port)
- dap_link_manager_link_update(&l_permalink_info->node_addr, l_permalink_info->uplink_addr, l_permalink_info->uplink_port);
}
if (a_new_state == NET_STATE_ONLINE)
dap_chain_esbocs_start_timer(a_net->pub.id);
@@ -396,10 +395,9 @@ int dap_chain_net_state_go_to(dap_chain_net_t *a_net, dap_chain_net_state_t a_ne
return dap_proc_thread_callback_add(NULL, s_net_states_proc, a_net);
}
-dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t *a_net)
+DAP_INLINE dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t *a_net)
{
- dap_chain_net_state_t l_ret = PVT(a_net)->state_target;
- return l_ret;
+ return PVT(a_net)->state_target;
}
static struct request_link_info *s_balancer_link_from_cfg(dap_chain_net_t *a_net)
@@ -1211,26 +1209,18 @@ static int s_cli_net(int argc, char **argv, void **reply)
dap_json_rpc_allocation_error;
return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
}
- if (l_from_str) {
- json_object *l_jobj_from = json_object_new_string(l_from_str);
- if (!l_jobj_from) {
- json_object_put(l_jobj_return);
- json_object_put(l_jobj_stats);
- dap_json_rpc_allocation_error;
- return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
- }
- json_object_object_add(l_jobj_stats, "from", l_jobj_from);
- }
- if (l_to_str) {
- json_object *l_jobj_to = json_object_new_string(l_to_str);
- if (!l_jobj_to) {
- json_object_put(l_jobj_return);
- json_object_put(l_jobj_stats);
- dap_json_rpc_allocation_error;
- return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
- }
- json_object_object_add(l_jobj_stats, "to", l_jobj_to);
+ json_object *l_jobj_from = json_object_new_string(l_from_str_new);
+ json_object *l_jobj_to = json_object_new_string(l_to_str_new);
+ if (!l_jobj_from || !l_jobj_to) {
+ json_object_put(l_jobj_return);
+ json_object_put(l_jobj_stats);
+ json_object_put(l_jobj_from);
+ json_object_put(l_jobj_to);
+ dap_json_rpc_allocation_error;
+ return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
}
+ json_object_object_add(l_jobj_stats, "from", l_jobj_from);
+ json_object_object_add(l_jobj_stats, "to", l_jobj_to);
log_it(L_INFO, "Calc TPS from %s to %s", l_from_str_new, l_to_str_new);
uint64_t l_tx_count = dap_ledger_count_from_to ( l_net->pub.ledger, l_from_ts, l_to_ts);
long double l_tpd = l_to_ts == l_from_ts ? 0 :
@@ -1239,74 +1229,38 @@ static int s_cli_net(int argc, char **argv, void **reply)
json_object *l_jobj_tpd = json_object_new_string(l_tpd_str);
DAP_DELETE(l_tpd_str);
json_object *l_jobj_total = json_object_new_uint64(l_tx_count);
+#ifdef DAP_TPS_TEST
+ long double l_tps = l_to_ts == l_from_ts ? 0 :
+ (long double) l_tx_count / (long double) (long double)(l_to_ts - l_from_ts);
+ char *l_tps_str = dap_strdup_printf("%.3Lf", l_tps);
+ json_object *l_jobj_tps = json_object_new_string(l_tps_str);
+ DAP_DELETE(l_tps_str);
+ if (!l_jobj_tpd || !l_jobj_total || !l_jobj_tps) {
+ json_object_put(l_jobj_tps);
+#else
if (!l_jobj_tpd || !l_jobj_total) {
+#endif
+
json_object_put(l_jobj_return);
json_object_put(l_jobj_stats);
+ json_object_put(l_jobj_from);
+ json_object_put(l_jobj_to);
json_object_put(l_jobj_tpd);
json_object_put(l_jobj_total);
dap_json_rpc_allocation_error;
return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
}
+#ifdef DAP_TPS_TEST
+ json_object_object_add(l_jobj_stats, "transaction_per_sec", l_jobj_tps);
+#endif
json_object_object_add(l_jobj_stats, "transaction_per_day", l_jobj_tpd);
json_object_object_add(l_jobj_stats, "total", l_jobj_total);
json_object_object_add(l_jobj_return, "transaction_statistics", l_jobj_stats);
l_ret = DAP_CHAIN_NET_JSON_RPC_OK;
- }
-#ifdef DAP_TPS_TEST
- else if (strcmp(l_stats_str, "tps") == 0) {
- struct timespec l_from_time_acc = {}, l_to_time_acc = {};
- json_object *l_jobj_values = json_object_new_object();
- if (!l_jobj_values) {
- dap_json_rpc_allocation_error;
- return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
- }
- size_t l_tx_num = dap_ledger_count_tps(l_net->pub.ledger, &l_from_time_acc, &l_to_time_acc);
- if (l_tx_num) {
- localtime_r(&l_from_time_acc.tv_sec, &l_from_tm);
- strftime(l_from_str_new, sizeof(l_from_str_new), c_time_fmt, &l_from_tm);
- localtime_r(&l_to_time_acc.tv_sec, &l_to_tm);
- strftime(l_to_str_new, sizeof(l_to_str_new), c_time_fmt, &l_to_tm);
- json_object *l_jobj_from = json_object_new_string(l_from_str_new);
- json_object *l_jobj_to = json_object_new_string(l_to_str_new);
- uint64_t l_diff_ns = (l_to_time_acc.tv_sec - l_from_time_acc.tv_sec) * 1000000000 +
- l_to_time_acc.tv_nsec - l_from_time_acc.tv_nsec;
- long double l_tps = (long double)(l_tx_num * 1000000000) / (long double)(l_diff_ns);
- char *l_tps_str = dap_strdup_printf("%.3Lf", l_tps);
- json_object *l_jobj_tps = json_object_new_string(l_tps_str);
- DAP_DELETE(l_tps_str);
- if (!l_jobj_from || !l_jobj_to || !l_jobj_tps) {
- json_object_put(l_jobj_return);
- json_object_put(l_jobj_values);
- json_object_put(l_jobj_from);
- json_object_put(l_jobj_to);
- json_object_put(l_jobj_tps);
- dap_json_rpc_allocation_error;
- return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
- }
- json_object_object_add(l_jobj_values, "from", l_jobj_from);
- json_object_object_add(l_jobj_values, "to", l_jobj_to);
- json_object_object_add(l_jobj_values, "tps", l_jobj_tps);
- }
- json_object *l_jobj_total = json_object_new_uint64(l_tx_num);
- if (!l_jobj_total) {
- json_object_put(l_jobj_return);
- json_object_put(l_jobj_values);
- dap_json_rpc_allocation_error;
- return DAP_JSON_RPC_ERR_CODE_MEMORY_ALLOCATED;
- }
- json_object_object_add(l_jobj_values, "total", l_jobj_total);
- json_object_object_add(l_jobj_return, "transactions_per_second_peak", l_jobj_values);
- l_ret = DAP_CHAIN_NET_JSON_RPC_OK;
- }
-#endif
- else {
+ } else {
json_object_put(l_jobj_return);
-#ifdef DAP_TPS_TEST
- dap_json_rpc_error_add(DAP_CHAIN_NET_JSON_RPC_UNDEFINED_PARAMETER_COMMAND_STATS, "Subcommand 'stats' requires one of parameter: tx, tps");
-#else
dap_json_rpc_error_add(DAP_CHAIN_NET_JSON_RPC_UNDEFINED_PARAMETER_COMMAND_STATS, "%s",
"Subcommand 'stats' requires one of parameter: tx");
-#endif
return DAP_CHAIN_NET_JSON_RPC_UNDEFINED_PARAMETER_COMMAND_STATS;
}
} else if ( l_go_str){
@@ -1957,7 +1911,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
return -4;
}
if (dap_stream_node_addr_from_str(&l_net_pvt->permanent_links[i]->node_addr, l_permanent_nodes_addrs[i])) {
- log_it(L_ERROR, "Incorrect format of address \"%s\", fix net config and restart node", l_permanent_nodes_addrs[i]);
+ log_it(L_ERROR, "Incorrect format of node address \"%s\", fix net config and restart node", l_permanent_nodes_addrs[i]);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -16;
@@ -1969,7 +1923,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
uint16_t l_port = 0;
char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' };
if (dap_net_parse_hostname(l_permanent_links_hosts[i], l_host, &l_port) || !l_port) {
- log_it(L_ERROR, "Incorrect format of address \"%s\", fix net config and restart node",
+ log_it(L_ERROR, "Incorrect format of host \"%s\", fix net config or recheck internet connection, and restart node",
l_permanent_links_hosts[i]);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
@@ -1987,7 +1941,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
for (uint16_t i = 0; i < l_net_pvt->authorized_nodes_count; ++i) {
dap_chain_node_addr_t l_addr;
if (dap_stream_node_addr_from_str(&l_addr, l_authorized_nodes_addrs[i])) {
- log_it(L_ERROR, "Incorrect format of address \"%s\", fix net config and restart node", l_authorized_nodes_addrs[i]);
+ log_it(L_ERROR, "Incorrect format of node address \"%s\", fix net config and restart node", l_authorized_nodes_addrs[i]);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -17;
@@ -2009,7 +1963,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
uint16_t l_port = 0;
char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' };
if (dap_net_parse_hostname(l_seed_nodes_hosts[i], l_host, &l_port) || !l_port) {
- log_it(L_ERROR, "Incorrect format of address \"%s\", fix net config and restart node",
+ log_it(L_ERROR, "Incorrect format of host \"%s\", fix net config or recheck internet connection, and restart node",
l_seed_nodes_hosts[i]);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
@@ -3205,7 +3159,7 @@ int dap_chain_datum_add(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t
log_it(L_WARNING, "Corrupted anchor, datum size %zd is not equal to size of anchor %zd", l_datum_data_size, l_anchor_size);
return -102;
}
- return dap_chain_net_anchor_load(l_anchor, a_chain);
+ return dap_chain_net_anchor_load(l_anchor, a_chain, a_datum_hash);
}
case DAP_CHAIN_DATUM_TOKEN_DECL:
return dap_ledger_token_load(l_ledger, a_datum->data, a_datum->header.data_size);
@@ -3217,7 +3171,7 @@ int dap_chain_datum_add(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t *)a_datum->data;
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
if (l_tx_size != l_datum_data_size) {
- log_it(L_WARNING, "Corrupted trnsaction, datum size %zd is not equal to size of TX %zd", l_datum_data_size, l_tx_size);
+ log_it(L_WARNING, "Corrupted transaction, datum size %zd is not equal to size of TX %zd", l_datum_data_size, l_tx_size);
return -102;
}
return dap_ledger_tx_load(l_ledger, l_tx, a_datum_hash);
@@ -3252,32 +3206,22 @@ int dap_chain_datum_remove(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, siz
dap_ledger_t *l_ledger = dap_chain_net_by_id(a_chain->net_id)->pub.ledger;
switch (a_datum->header.type_id) {
case DAP_CHAIN_DATUM_DECREE: {
- /*dap_chain_datum_decree_t *l_decree = (dap_chain_datum_decree_t *)a_datum->data;
- size_t l_decree_size = dap_chain_datum_decree_get_size(l_decree);
- if (l_decree_size != l_datum_data_size) {
- log_it(L_WARNING, "Corrupted decree, datum size %zd is not equal to size of decree %zd", l_datum_data_size, l_decree_size);
- return -102;
- }*/
- return 0; //dap_chain_net_decree_load(l_decree, a_chain, a_datum_hash);
+ return 0;
}
case DAP_CHAIN_DATUM_ANCHOR: {
dap_chain_datum_anchor_t *l_anchor = (dap_chain_datum_anchor_t *)a_datum->data;
-
-
-
size_t l_anchor_size = dap_chain_datum_anchor_get_size(l_anchor);
if (l_anchor_size != l_datum_data_size) {
log_it(L_WARNING, "Corrupted anchor, datum size %zd is not equal to size of anchor %zd", l_datum_data_size, l_anchor_size);
return -102;
}
- return dap_chain_net_anchor_unload(l_anchor, a_chain);
+ return dap_chain_net_anchor_unload(l_anchor, a_chain, a_datum_hash);
}
case DAP_CHAIN_DATUM_TOKEN_DECL:
- return 0;//dap_ledger_token_load(l_ledger, a_datum->data, a_datum->header.data_size);
+ return 0;
case DAP_CHAIN_DATUM_TOKEN_EMISSION:
- return 0;//dap_ledger_token_emission_load(l_ledger, a_datum->data, a_datum->header.data_size, a_datum_hash);
-
+ return 0;
case DAP_CHAIN_DATUM_TX: {
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t *)a_datum->data;
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
@@ -3365,4 +3309,8 @@ void dap_chain_net_set_net_decree(dap_chain_net_t *a_net, dap_chain_net_decree_t
decree_table_t **dap_chain_net_get_decrees(dap_chain_net_t *a_net) {
return a_net ? &(PVT(a_net)->decrees) : NULL;
+}
+
+anchor_table_t **dap_chain_net_get_anchors(dap_chain_net_t *a_net) {
+ return a_net ? &(PVT(a_net)->anchors) : NULL;
}
\ No newline at end of file
diff --git a/modules/net/dap_chain_net_anchor.c b/modules/net/dap_chain_net_anchor.c
index 2fab9b011989ffbf390aae33f44aa85aee285014..dde964b2d4481c500b626c1d207c35fb8059f107 100644
--- a/modules/net/dap_chain_net_anchor.c
+++ b/modules/net/dap_chain_net_anchor.c
@@ -40,6 +40,12 @@
#define LOG_TAG "chain_net_anchor"
+typedef struct anchor_table{
+ dap_hash_fast_t anchor_hash;
+ dap_chain_datum_anchor_t *anchor;
+ UT_hash_handle hh;
+} anchor_table_t;
+
// private function prototypes
static bool s_verify_pubkeys(dap_sign_t *a_sign, dap_sign_t **a_decree_signs, size_t a_num_of_decree_sign);
static inline dap_sign_t *s_concate_all_signs_in_array(dap_sign_t *a_in_signs, size_t a_signs_size, size_t *a_sings_count, size_t *a_signs_arr_size);
@@ -134,7 +140,7 @@ int dap_chain_net_anchor_verify(dap_chain_net_t *a_net, dap_chain_datum_anchor_t
return s_anchor_verify(a_net, a_anchor, a_data_size, false);
}
-int dap_chain_net_anchor_load(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain)
+int dap_chain_net_anchor_load(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain, dap_hash_fast_t *a_anchor_hash)
{
int ret_val = 0;
@@ -165,90 +171,106 @@ int dap_chain_net_anchor_load(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *
return -109;
}
- if ((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain)) != 0)
+ if ((ret_val = dap_chain_net_decree_apply(&l_hash, NULL, a_chain)) != 0){
log_it(L_WARNING, "Decree applying failed");
+ return ret_val;
+ }
+
+
+ anchor_table_t **l_anchors = dap_chain_net_get_anchors(l_net);
+ anchor_table_t *l_new_anchor = DAP_NEW_Z(anchor_table_t);
+ l_new_anchor->anchor_hash = *a_anchor_hash;
+ l_new_anchor->anchor = a_anchor;
+ HASH_ADD(hh, *l_anchors, anchor_hash, sizeof(l_new_anchor->anchor_hash), l_new_anchor);
return ret_val;
}
-dap_chain_datum_anchor_t * s_find_previous_anchor(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain)
+dap_chain_datum_anchor_t * s_find_previous_anchor(dap_hash_fast_t *a_old_anchor_hash, dap_chain_net_t *a_net)
{
- if (!a_anchor || !a_chain){
+ if (!a_old_anchor_hash || !a_net){
log_it(L_ERROR,"Params are NULL");
return NULL;
}
- dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
+
+ dap_chain_net_t *l_net = a_net;
dap_chain_datum_anchor_t * l_ret_anchor = NULL;
+ dap_chain_datum_anchor_t *l_old_anchor = NULL;
+
+ anchor_table_t **l_anchors_ptr = dap_chain_net_get_anchors(l_net);
+ anchor_table_t *l_anchor = NULL;
+ HASH_FIND(hh, *l_anchors_ptr, a_old_anchor_hash, sizeof(*a_old_anchor_hash), l_anchor);
+ if (!l_old_anchor){
+ log_it(L_WARNING,"Can not find anchor");
+ return NULL;
+ }
+
+ l_old_anchor = l_anchor->anchor;
dap_hash_fast_t l_old_decrere_hash = {};
- if (dap_chain_datum_anchor_get_hash_from_data(a_anchor, &l_old_decrere_hash) != 0)
+ if (dap_chain_datum_anchor_get_hash_from_data(l_old_anchor, &l_old_decrere_hash) != 0)
return NULL;
dap_chain_datum_decree_t *l_old_decree = dap_chain_net_decree_get_by_hash(l_net, &l_old_decrere_hash, NULL);
uint16_t l_old_decree_type = l_old_decree->header.type;
uint16_t l_old_decree_subtype = l_old_decree->header.sub_type;
- dap_chain_cell_t *l_cell = a_chain->cells;
- size_t l_atom_size = 0;
- dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id, 0);
- dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get(l_atom_iter, DAP_CHAIN_ITER_OP_LAST, &l_atom_size);
- while(l_atom && l_atom_size){
+ anchor_table_t *l_anchors = HASH_LAST(*l_anchors_ptr);
+ for(; l_anchors; l_anchors = l_anchors->hh.prev){
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);
- dap_chain_datum_t *l_datum, *l_datum2;
- for(size_t l_datum_n = 0; l_datum_n < l_datums_count; l_datum_n++) {
- if ( ! (l_datum = l_datums[l_datum_n]) )
- continue;
-
- if (l_datum->header.type_id != DAP_CHAIN_DATUM_ANCHOR || a_anchor == (dap_chain_datum_anchor_t *)l_datum->data)
- continue;
- dap_chain_datum_anchor_t *l_curr_anchor = (dap_chain_datum_anchor_t *)l_datum->data;
- dap_hash_fast_t l_hash = {};
- if (dap_chain_datum_anchor_get_hash_from_data(l_curr_anchor, &l_hash) != 0)
- continue;
+ dap_chain_datum_anchor_t *l_curr_anchor = l_anchors->anchor;
+ dap_hash_fast_t l_hash = {};
+ if (dap_chain_datum_anchor_get_hash_from_data(l_curr_anchor, &l_hash) != 0)
+ continue;
+
+ bool l_is_applied = false;
+ dap_chain_datum_decree_t *l_decree = dap_chain_net_decree_get_by_hash(l_net, &l_hash, &l_is_applied);
+ if (!l_decree)
+ continue;
+
+ if (l_decree->header.type == l_old_decree_type && l_old_decree_type == DAP_CHAIN_DATUM_DECREE_TYPE_COMMON &&
+ l_old_decree_subtype == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_INVALIDATE &&
+ l_decree->header.sub_type == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_APPROVE){
- bool l_is_applied = false;
- dap_chain_datum_decree_t *l_decree = dap_chain_net_decree_get_by_hash(l_net, &l_hash, &l_is_applied);
- if (!l_decree)
+ dap_chain_addr_t l_addr_old, l_addr_new = {};
+ if (dap_chain_datum_decree_get_stake_signing_addr(l_old_decree, &l_addr_old)){
continue;
+ }
- if (l_decree->header.type == l_old_decree_type && l_old_decree_type == DAP_CHAIN_DATUM_DECREE_TYPE_COMMON &&
- l_old_decree_subtype == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_INVALIDATE &&
- l_decree->header.sub_type == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_APPROVE){
-
- dap_chain_addr_t l_addr_old, l_addr_new = {};
- if (dap_chain_datum_decree_get_stake_signing_addr(l_old_decree, &l_addr_old)){
- continue;
- }
-
- if (dap_chain_datum_decree_get_stake_signing_addr(l_decree, &l_addr_new)){
- continue;
- }
+ if (dap_chain_datum_decree_get_stake_signing_addr(l_decree, &l_addr_new)){
+ continue;
+ }
- if(dap_chain_addr_compare(&l_addr_old, &l_addr_new)){
- l_ret_anchor = l_curr_anchor;
- dap_chain_net_decree_reset_applied(l_net, &l_hash);
- break;
- }
- } else if (l_decree->header.type == l_old_decree_type && l_decree->header.sub_type == l_old_decree_subtype){
- // check addr if l_decree type is stake approve
+ if(dap_chain_addr_compare(&l_addr_old, &l_addr_new)){
l_ret_anchor = l_curr_anchor;
dap_chain_net_decree_reset_applied(l_net, &l_hash);
- break;
+ break;
}
+ } else if (l_decree->header.type == l_old_decree_type && l_decree->header.sub_type == l_old_decree_subtype){
+ // check addr if l_decree type is stake approve
+ l_ret_anchor = l_curr_anchor;
+ dap_chain_net_decree_reset_applied(l_net, &l_hash);
+ break;
}
- DAP_DEL_Z(l_datums);
if (l_ret_anchor)
break;
- // go to previous atom
- l_atom = a_chain->callback_atom_iter_get(l_atom_iter, DAP_CHAIN_ITER_OP_PREV, &l_atom_size);
}
- a_chain->callback_atom_iter_delete(l_atom_iter);
return l_ret_anchor;
}
-int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain)
+void s_delete_anchor(dap_chain_net_t *a_net, dap_hash_fast_t *a_anchor_hash)
+{
+ anchor_table_t **l_anchors_ptr = dap_chain_net_get_anchors(a_net);
+ anchor_table_t *l_anchor = NULL;
+ HASH_FIND(hh, *l_anchors_ptr, a_anchor_hash, sizeof(*a_anchor_hash), l_anchor);
+ if(l_anchor){
+ HASH_DEL(*l_anchors_ptr, l_anchor);
+ DAP_DEL_Z(l_anchor);
+ }
+}
+
+int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain, dap_hash_fast_t *a_anchor_hash)
{
int ret_val = 0;
@@ -287,7 +309,8 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
{
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_FEE:{
dap_chain_net_decree_reset_applied(l_net, &l_hash);
- dap_chain_datum_anchor_t * l_new_anchor = s_find_previous_anchor(a_anchor, a_chain);
+ dap_chain_datum_anchor_t * l_new_anchor = s_find_previous_anchor(a_anchor_hash, l_net);
+ s_delete_anchor(l_net, a_anchor_hash);
if (l_new_anchor){// if previous anchor is founded apply it
dap_chain_hash_fast_t l_hash = {0};
if ((ret_val = dap_chain_datum_anchor_get_hash_from_data(l_new_anchor, &l_hash)) != 0){
@@ -317,12 +340,14 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
}
dap_chain_net_srv_stake_key_invalidate(&l_signing_addr);
dap_chain_net_decree_reset_applied(l_net, &l_hash);
+ s_delete_anchor(l_net, a_anchor_hash);
}
break;
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_INVALIDATE:{
// Find previous anchor with this stake approve and apply it
dap_chain_net_decree_reset_applied(l_net, &l_hash);
dap_chain_datum_anchor_t * l_new_anchor = s_find_previous_anchor(a_anchor, a_chain);
+ s_delete_anchor(l_net, a_anchor_hash);
if (l_new_anchor){// if previous anchor is founded apply it
dap_chain_hash_fast_t l_hash = {0};
if ((ret_val = dap_chain_datum_anchor_get_hash_from_data(l_new_anchor, &l_hash)) != 0){
@@ -339,6 +364,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_MIN_VALUE:{
dap_chain_net_decree_reset_applied(l_net, &l_hash);
dap_chain_datum_anchor_t * l_new_anchor = s_find_previous_anchor(a_anchor, a_chain);
+ s_delete_anchor(l_net, a_anchor_hash);
if (l_new_anchor){// if previous anchor is founded apply it
dap_chain_hash_fast_t l_hash = {0};
if ((ret_val = dap_chain_datum_anchor_get_hash_from_data(l_new_anchor, &l_hash)) != 0){
@@ -358,6 +384,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_MIN_VALIDATORS_COUNT:{
dap_chain_net_decree_reset_applied(l_net, &l_hash);
dap_chain_datum_anchor_t * l_new_anchor = s_find_previous_anchor(a_anchor, a_chain);
+ s_delete_anchor(l_net, a_anchor_hash);
if (l_new_anchor){// if previous anchor is founded apply it
dap_chain_hash_fast_t l_hash = {0};
if ((ret_val = dap_chain_datum_anchor_get_hash_from_data(l_new_anchor, &l_hash)) != 0){
@@ -378,6 +405,7 @@ int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t
// find previous anchor with rewarrd and apply it
dap_chain_net_decree_reset_applied(l_net, &l_hash);
dap_chain_net_remove_last_reward(dap_chain_net_by_id(a_chain->net_id));
+ s_delete_anchor(l_net, a_anchor_hash);
}
break;
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_OWNERS:
diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index cbe144ca641039acf49446974037904599bc0397..182a023c9666be4622647e296362905be77c1eb9 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -153,7 +153,7 @@ static void s_balancer_link_prepare_error(dap_balancer_link_request_t *a_request
struct json_object *l_json = s_balancer_states_json_collect(a_request->net, a_host_addr, a_host_port);
char l_err_str[512] = { '\0' };
snprintf(l_err_str, sizeof(l_err_str)
- , "Link from balancer %s:%u in net %s can't be prepared, errno %d"
+ , "Links from balancer %s:%u in net %s can't be prepared, connection errno %d"
, a_host_addr, a_host_port, a_request->net->pub.name, a_errno);
log_it(L_WARNING, "%s", l_err_str);
json_object_object_add(l_json, "errorMessage", json_object_new_string(l_err_str));
@@ -172,7 +172,7 @@ void s_http_balancer_link_prepare_success(void *a_response,
{
dap_balancer_link_request_t *l_balancer_request = (dap_balancer_link_request_t *)a_arg;
if (a_response_code != 200) {
- log_it(L_ERROR, "The server responded with code %d. It is not possible to install the link.", a_response_code);
+ log_it(L_ERROR, "The server responded with code %d. It is not possible to install the link to %s:%u in net %s", a_response_code, l_balancer_request->host_addr, l_balancer_request->host_port, l_balancer_request->net->pub.name);
s_balancer_link_prepare_error(l_balancer_request, l_balancer_request->host_addr, l_balancer_request->host_port, a_response_code);
l_balancer_request->request_info->request_time = dap_time_now();
DAP_DELETE(l_balancer_request);
@@ -185,6 +185,7 @@ void s_http_balancer_link_prepare_success(void *a_response,
log_it(L_ERROR, "Invalid balancer response size %zu (expected %zu) in net %s from %s:%u", a_response_size, l_response_size_need, l_balancer_request->net->pub.name, l_balancer_request->host_addr, l_balancer_request->host_port);
l_balancer_request->request_info->request_time = dap_time_now();
} else {
+ log_it(L_INFO, "Valid balancer response from %s:%u in net %s with %"DAP_UINT64_FORMAT_U" links", l_balancer_request->host_addr, l_balancer_request->host_port, l_balancer_request->net->pub.name, l_link_full_node_list->count_node);
s_balancer_link_prepare_success(l_balancer_request->net, l_link_full_node_list, l_balancer_request->host_addr, l_balancer_request->host_port);
l_balancer_request->request_info->request_time = 0;
}
@@ -220,7 +221,7 @@ static dap_chain_net_links_t *s_get_node_addrs(dap_chain_net_t *a_net, uint16_t
// preparing
dap_list_t *l_nodes_list = dap_chain_node_get_states_list_sort(a_net, a_ignored ? (dap_chain_node_addr_t *)a_ignored->nodes_info : (dap_chain_node_addr_t *)NULL, a_ignored ? a_ignored->count_node : 0);
if (!l_nodes_list) {
- log_it(L_DEBUG, "There isn't any nodes to list prepare in net %s", a_net->pub.name);
+ log_it(L_DEBUG, "There isn't any nodes to %s list prepare in net %s", a_external_call ? "external" : "local", a_net->pub.name);
if (!a_external_call)
return NULL;
}
@@ -357,7 +358,7 @@ int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_cha
*/
void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, void *a_arg)
{
- log_it(L_DEBUG,"Proc enc http request");
+ log_it(L_DEBUG,"Proc enc http request from %s", a_http_simple->es_hostaddr);
http_status_code_t *l_return_code = (http_status_code_t *)a_arg;
if (strcmp(a_http_simple->http_client->url_path, DAP_BALANCER_URI_HASH)) {
@@ -467,6 +468,7 @@ int dap_chain_net_balancer_request(dap_chain_net_t *a_net, const char *a_host_ad
*l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);
// links from local GDB
if (l_links) {
+ log_it(L_INFO, "%"DAP_UINT64_FORMAT_U" links successful prepared from global-db in net %s", l_links->count_node, a_net->pub.name);
s_balancer_link_prepare_success(a_net, l_links, NULL, 0);
if (l_links->count_node >= l_required_links_count) {
DAP_DEL_MULTY(l_ignored_addrs, l_links);
diff --git a/modules/net/dap_chain_net_decree.c b/modules/net/dap_chain_net_decree.c
index 9433256eb788451facee26a448f68c9b9409c27d..46d6c126472ff3e5c110872b348a772d2e4116d5 100644
--- a/modules/net/dap_chain_net_decree.c
+++ b/modules/net/dap_chain_net_decree.c
@@ -245,7 +245,6 @@ int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_d
decree_table_t **l_decrees = dap_chain_net_get_decrees(l_net), *l_new_decree;
HASH_FIND(hh, *l_decrees, a_decree_hash, sizeof(dap_hash_fast_t), l_new_decree);
-
if (!l_new_decree) {
l_new_decree = DAP_NEW_Z(decree_table_t);
if (!l_new_decree) {
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index 30f6b15d65ddddbe28d187e177fa922146f47ff3..829377cc7116c3a335b0924abc1850fc0ba48ca6 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -411,12 +411,6 @@ dap_list_t *dap_chain_node_get_states_list_sort(dap_chain_net_t *a_net, dap_chai
log_it(L_ERROR, "Invalid record, key %s", l_objs[i].key);
continue;
}
- dap_nanotime_t l_timestamp = 0;
- dap_chain_node_net_states_info_t *l_store_obj = (dap_chain_node_net_states_info_t *)dap_global_db_get_sync(l_gdb_group, l_objs[i].key, NULL, NULL, &l_timestamp);
- if (!l_store_obj) {
- log_it(L_ERROR, "Can't find state about %s node", l_objs[i].key);
- continue;
- }
bool l_ignored = false;
for(size_t j = 0; !l_ignored && j < a_ignored_count; ++j) {
l_ignored = a_ignored[j].uint64 == ((dap_chain_node_info_t*)(l_objs + i)->value)->address.uint64;
@@ -430,14 +424,19 @@ dap_list_t *dap_chain_node_get_states_list_sort(dap_chain_net_t *a_net, dap_chai
log_it(L_ERROR, "%s", g_error_memory_alloc);
break;
}
+ dap_nanotime_t l_state_timestamp = 0;
+ dap_chain_node_net_states_info_t *l_state_store_obj = (dap_chain_node_net_states_info_t *)dap_global_db_get_sync(l_gdb_group, l_objs[i].key, NULL, NULL, &l_state_timestamp);
+ if (!l_state_store_obj) {
+ log_it(L_WARNING, "Can't find state about %s node, apply low priority", l_objs[i].key);
+ }
l_item->link_info.node_addr.uint64 = ((dap_chain_node_info_t*)(l_objs + i)->value)->address.uint64;
l_item->link_info.uplink_port = ((dap_chain_node_info_t*)(l_objs + i)->value)->ext_port;
dap_strncpy(l_item->link_info.uplink_addr, ((dap_chain_node_info_t*)(l_objs + i)->value)->ext_host, sizeof(l_item->link_info.uplink_addr) - 1);
- l_item->atoms_count = l_store_obj->atoms_count;
- l_item->downlinks_count = l_store_obj->downlinks_count;
- l_item->timestamp = l_timestamp;
+ l_item->atoms_count = l_state_store_obj ? l_state_store_obj->atoms_count : 0;
+ l_item->downlinks_count = l_state_store_obj ? l_state_store_obj->downlinks_count : (uint32_t)(-1);
+ l_item->timestamp = l_state_timestamp;
l_ret = dap_list_insert_sorted(l_ret, (void *)l_item, s_node_states_info_cmp);
- DAP_DELETE(l_store_obj);
+ DAP_DELETE(l_state_store_obj);
}
DAP_DELETE(l_gdb_group);
dap_global_db_objs_delete(l_objs, l_node_count);
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index d6b35ecd5b50cd84336a70e26b599f57c9580798..6d3267ed4835fe7522f4a420ad5d746868957d79 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -3603,10 +3603,7 @@ int _cmd_mempool_proc_all(dap_chain_net_t *a_net, dap_chain_t *a_chain, void **a
json_object_object_add(l_ret, "warning", l_warn_obj);
}
-#ifdef DAP_TPS_TEST
- dap_chain_ledger_set_tps_start_time(a_net->pub.ledger);
-#endif
- dap_chain_node_mempool_process_all(a_chain, true);
+ dap_chain_node_mempool_process_all(a_chain, true);
char *l_str_result = dap_strdup_printf("The entire mempool has been processed in %s.%s.",
a_net->pub.name, a_chain->name);
if (!l_str_result) {
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index 709cfb6dc13dd96478f16fedb9e0b04bbc588b05..26a382ae19aeafd2e98ffe25d793b78b07cf191f 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -98,7 +98,6 @@ bool s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
const char *a_hash_out_type,
dap_chain_hash_fast_t *a_tx_hash)
{
- dap_time_t l_ts_create = (dap_time_t)a_datum->header.ts_created;
char l_tx_hash_str[70]={0};
char l_tmp_buf[DAP_TIME_STR_SIZE];
const char *l_ticker = a_ledger
@@ -107,7 +106,7 @@ bool s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
if (!l_ticker)
return false;
const char *l_description = dap_ledger_get_description_by_ticker(a_ledger, l_ticker);
- dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_ts_create);
+ dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, a_datum->header.ts_created);
dap_chain_hash_fast_to_str(a_tx_hash,l_tx_hash_str,sizeof(l_tx_hash_str));
json_object_object_add(json_obj_out, "Datum_tx_hash", json_object_new_string(l_tx_hash_str));
json_object_object_add(json_obj_out, "TS_Created", json_object_new_string(l_tmp_buf));
@@ -212,10 +211,7 @@ json_object * dap_db_tx_history_to_json(dap_chain_hash_fast_t* a_tx_hash,
}
char l_time_str[DAP_TIME_STR_SIZE];
- if (l_tx->header.ts_created) {
- dap_time_to_str_rfc822(l_time_str, DAP_TIME_STR_SIZE, l_tx->header.ts_created);/* Convert ts to "Sat May 17 01:17:08 2014\n" */
- l_time_str[strlen(l_time_str)-1] = '\0'; /* Remove "\n"*/
- }
+ dap_time_to_str_rfc822(l_time_str, DAP_TIME_STR_SIZE, l_tx->header.ts_created); /* Convert ts to "Sat May 17 01:17:08 2014" */
json_object *l_obj_ts_created = json_object_new_string(l_time_str);
json_object_object_add(json_obj_datum, "tx_created", l_obj_ts_created);
@@ -265,10 +261,8 @@ static void s_tx_header_print(json_object* json_obj_datum, dap_chain_tx_hash_pro
bool l_declined = false;
// transaction time
char l_time_str[DAP_TIME_STR_SIZE] = "unknown"; /* Prefill string */
- if (a_tx->header.ts_created) {
- dap_time_to_str_rfc822(l_time_str, DAP_TIME_STR_SIZE, a_tx->header.ts_created); /* Convert ts to "Sat May 17 01:17:08 2014\n" */
- l_time_str[strlen(l_time_str)-1] = '\0'; /* Remove "\n"*/
- }
+ if (a_tx->header.ts_created)
+ dap_time_to_str_rfc822(l_time_str, DAP_TIME_STR_SIZE, a_tx->header.ts_created); /* Convert ts to "Sat May 17 01:17:08 2014" */
dap_chain_tx_hash_processed_ht_t *l_tx_data = NULL;
HASH_FIND(hh, *a_tx_data_ht, a_tx_hash, sizeof(*a_tx_hash), l_tx_data);
if (l_tx_data) // this tx already present in ledger (double)
@@ -817,48 +811,38 @@ json_object *dap_db_history_tx_all(dap_chain_t *l_chain, dap_chain_net_t *l_net,
* @param a_token_num
* @return char*
*/
-static json_object* dap_db_chain_history_token_list(dap_chain_t * a_chain, const char *a_token_name, const char *a_hash_out_type, size_t *a_token_num) {
- if (!a_chain->callback_atom_get_datums) {
- log_it(L_WARNING, "Not defined callback_atom_get_datums for chain \"%s\"", a_chain->name);
+static json_object* dap_db_chain_history_token_list(dap_chain_t * a_chain, const char *a_token_name, const char *a_hash_out_type, size_t *a_token_num)
+{
+ if (!a_chain->callback_datum_iter_create) {
+ log_it(L_WARNING, "Not defined datum iterators for chain \"%s\"", a_chain->name);
return NULL;
}
- *a_token_num = 0;
- size_t l_atom_size = 0;
- dap_chain_cell_t *l_cell = a_chain->cells;
+ size_t l_token_num = 0;
json_object* json_arr_history_token_out = json_object_new_array();
- do {
- dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id, NULL);
- if(!a_chain->callback_atom_get_datums) {
- log_it(L_DEBUG, "Not defined callback_atom_get_datums for chain \"%s\"", a_chain->name);
- json_object_put(json_arr_history_token_out);
- return NULL ;
- }
- for (dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get(l_atom_iter, DAP_CHAIN_ITER_OP_FIRST, &l_atom_size);
- l_atom && l_atom_size; l_atom = a_chain->callback_atom_iter_get(l_atom_iter, DAP_CHAIN_ITER_OP_NEXT, &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 l_datum_n = 0; l_datum_n < l_datums_count; l_datum_n++) {
- dap_chain_datum_t *l_datum = l_datums[l_datum_n];
- if (!l_datum || l_datum->header.type_id != DAP_CHAIN_DATUM_TOKEN_DECL)
- continue;
- if (a_token_name) {
- size_t l_token_size = l_datum->header.data_size;
- dap_chain_datum_token_t *l_token = dap_chain_datum_token_read(l_datum->data, &l_token_size);
- int l_cmp = dap_strcmp(l_token->ticker, a_token_name);
- DAP_DELETE(l_token);
- if (l_cmp)
- continue;
- }
- json_object* json_history_token = json_object_new_object();
- dap_chain_datum_dump_json(json_history_token, l_datum, a_hash_out_type, a_chain->net_id);
- json_object_array_add(json_arr_history_token_out, json_history_token);
- (*a_token_num)++;
- }
- DAP_DELETE(l_datums);
+ dap_chain_datum_iter_t *l_datum_iter = a_chain->callback_datum_iter_create(a_chain);
+ for (dap_chain_datum_t *l_datum = a_chain->callback_datum_iter_get_first(l_datum_iter);
+ l_datum; l_datum = a_chain->callback_datum_iter_get_next(l_datum_iter)) {
+ if (l_datum->header.type_id != DAP_CHAIN_DATUM_TOKEN_DECL)
+ continue;
+ if (a_token_name) {
+ size_t l_token_size = l_datum->header.data_size;
+ dap_chain_datum_token_t *l_token = dap_chain_datum_token_read(l_datum->data, &l_token_size);
+ int l_cmp = dap_strcmp(l_token->ticker, a_token_name);
+ DAP_DELETE(l_token);
+ if (l_cmp)
+ continue;
}
- a_chain->callback_atom_iter_delete(l_atom_iter);
- l_cell = l_cell->hh.next;
- } while (l_cell);
+ int l_ret_code = l_datum_iter->ret_code;
+ json_object* json_history_token = json_object_new_object();
+ json_object_object_add(json_history_token, "status", json_object_new_string(l_ret_code ? "DECLINED" : "ACCEPTED"));
+ json_object_object_add(json_history_token, "Ledger return code", json_object_new_int(l_ret_code));
+ dap_chain_datum_dump_json(json_history_token, l_datum, a_hash_out_type, a_chain->net_id);
+ json_object_array_add(json_arr_history_token_out, json_history_token);
+ l_token_num++;
+ }
+ a_chain->callback_datum_iter_delete(l_datum_iter);
+ if (a_token_num)
+ *a_token_num = l_token_num;
return json_arr_history_token_out;
}
diff --git a/modules/net/include/dap_chain_ledger.h b/modules/net/include/dap_chain_ledger.h
index a9b58d5bc4b9a86817fd7b3aadc31e02ef3a549e..4766bae94587acbf22012d81a82eb183e08b5121 100644
--- a/modules/net/include/dap_chain_ledger.h
+++ b/modules/net/include/dap_chain_ledger.h
@@ -339,8 +339,6 @@ void dap_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db);
*/
unsigned dap_ledger_count(dap_ledger_t *a_ledger);
uint64_t dap_ledger_count_from_to(dap_ledger_t * a_ledger, dap_time_t a_ts_from, dap_time_t a_ts_to);
-size_t dap_ledger_count_tps(dap_ledger_t *a_ledger, struct timespec *a_ts_from, struct timespec *a_ts_to);
-void dap_ledger_set_tps_start_time(dap_ledger_t *a_ledger);
/**
* Check whether used 'out' items
diff --git a/modules/net/include/dap_chain_net.h b/modules/net/include/dap_chain_net.h
index 6e9f139a5223f361a849eda5c49a5c7c1f25c485..6e62d461f70fb3948bcfad59038a16bd2368dedb 100644
--- a/modules/net/include/dap_chain_net.h
+++ b/modules/net/include/dap_chain_net.h
@@ -44,6 +44,7 @@ typedef struct dap_chain_node_client dap_chain_node_client_t;
typedef struct dap_ledger dap_ledger_t;
typedef struct dap_chain_net_decree dap_chain_net_decree_t;
typedef struct decree_table decree_table_t;
+typedef struct anchor_table anchor_table_t;
typedef enum dap_chain_net_state {
NET_STATE_OFFLINE = 0,
NET_STATE_LINKS_PREPARE,
@@ -233,4 +234,5 @@ enum dap_chain_net_json_rpc_error_list{
};
dap_chain_net_decree_t *dap_chain_net_get_net_decree(dap_chain_net_t *a_net);
void dap_chain_net_set_net_decree(dap_chain_net_t *a_net, dap_chain_net_decree_t *a_decree);
-decree_table_t **dap_chain_net_get_decrees(dap_chain_net_t *a_net);
\ No newline at end of file
+decree_table_t **dap_chain_net_get_decrees(dap_chain_net_t *a_net);
+anchor_table_t **dap_chain_net_get_anchors(dap_chain_net_t *a_net);
\ No newline at end of file
diff --git a/modules/net/include/dap_chain_net_anchor.h b/modules/net/include/dap_chain_net_anchor.h
index 1a44cab2a1f10439cd03d4c91b355c78d3380355..7275e2c2b3ca0e4143c30f692de3f471b72a9dc4 100644
--- a/modules/net/include/dap_chain_net_anchor.h
+++ b/modules/net/include/dap_chain_net_anchor.h
@@ -24,6 +24,8 @@
#include "dap_chain_datum_anchor.h"
#include "dap_chain_net.h"
+int dap_chain_net_anchor_init(dap_chain_net_t *a_net);
+
int dap_chain_net_anchor_verify(dap_chain_net_t *a_net, dap_chain_datum_anchor_t * a_anchor, size_t a_data_size);
-int dap_chain_net_anchor_load(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain);
-int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain);
\ No newline at end of file
+int dap_chain_net_anchor_load(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain, dap_hash_fast_t *a_anchor_hash);
+int dap_chain_net_anchor_unload(dap_chain_datum_anchor_t * a_anchor, dap_chain_t *a_chain, dap_hash_fast_t *a_anchor_hash);
\ No newline at end of file
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 e7c6ef181634c2e4b8b2090d662c340d611ca169..da0faa4edcb4e6ecf8c4b3ce6bb26ce8d47c4009 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
@@ -2216,9 +2216,8 @@ static int s_callback_compare_tx_list(dap_list_t *a_datum1, dap_list_t *a_datum2
int dap_chain_net_srv_stake_check_validator(dap_chain_net_t * a_net, dap_hash_fast_t *a_tx_hash, dap_chain_ch_validator_test_t * out_data,
int a_time_connect, int a_time_respone)
{
- char *l_key = NULL;
size_t l_node_info_size = 0;
- uint8_t l_test_data[1024] = {0};
+ uint8_t l_test_data[DAP_CHAIN_NET_CH_VALIDATOR_READY_REQUEST_SIZE] = {0};
dap_chain_node_client_t *l_node_client = NULL;
dap_chain_node_info_t *l_remote_node_info = NULL;
dap_ledger_t *l_ledger = dap_ledger_by_net_name(a_net->pub.name);
diff --git a/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h b/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h
index 0469a280fca7fad2314fcaa23b313c07616db1f0..19ca297c30461b77eaabcba70e1fca5096f64dfe 100644
--- a/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h
+++ b/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h
@@ -45,7 +45,6 @@ typedef struct dap_chain_net_srv_stake_item {
UT_hash_handle hh, ht;
} dap_chain_net_srv_stake_item_t;
-
typedef struct dap_chain_net_srv_stake_cache_data {
dap_chain_hash_fast_t tx_hash;
dap_chain_addr_t signing_addr;
diff --git a/modules/service/xchange/dap_chain_net_srv_xchange.c b/modules/service/xchange/dap_chain_net_srv_xchange.c
index e0cd881759eca86387e9f19fccbdcc42c57d51c6..0040e2d36fff4a4fcd381031c89b0a52d9209d81 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -1568,17 +1568,14 @@ static int s_cli_srv_xchange_order(int a_argc, char **a_argv, int a_arg_index, v
l_cp_rate = dap_chain_balance_to_coins(l_price->rate); // must be free'd
- char l_tmp_buf[DAP_TIME_STR_SIZE] = {};
- dap_time_t l_ts_create = (dap_time_t)l_tx->header.ts_created;
- dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_ts_create);
- l_tmp_buf[strlen(l_tmp_buf) - 1] = '\0';
-
+ char l_tmp_buf[DAP_TIME_STR_SIZE];
+ dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_tx->header.ts_created);
if (l_out_cond_last_tx)
l_amount_datoshi_str = dap_uint256_to_char(l_out_cond_last_tx->header.value, &l_amount_coins_str);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "orderHash: %s\n ts_created: %s (%"DAP_UINT64_FORMAT_U")\n Status: %s, amount: %s (%s) %s, filled: %lu%%, rate (%s/%s): %s, net: %s\n\n",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "orderHash: %s\n ts_created: %s\n Status: %s, amount: %s (%s) %s, filled: %lu%%, rate (%s/%s): %s, net: %s\n\n",
dap_chain_hash_fast_to_str_static(&l_tx_hash),
- l_tmp_buf, l_ts_create, l_status_order,
+ l_tmp_buf, l_status_order,
l_amount_coins_str ? l_amount_coins_str : "0.0",
l_amount_datoshi_str ? l_amount_datoshi_str : "0",
l_price->token_sell, l_percent_completed,
@@ -2118,16 +2115,13 @@ static int s_cli_srv_xchange(int a_argc, char **a_argv, void **a_str_reply)
uint64_t l_percent_completed = dap_chain_net_srv_xchange_get_order_completion_rate(l_net, l_tx_hash);
char l_tmp_buf[DAP_TIME_STR_SIZE];
- dap_time_t l_ts_create = l_tx->header.ts_created;
- dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_ts_create);
- l_tmp_buf[strlen(l_tmp_buf) - 1] = '\0';
-
+ dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_tx->header.ts_created);
l_cp_rate = dap_chain_balance_to_coins(l_price->rate);
const char *l_amount_coins_str = NULL,
*l_amount_datoshi_str = l_out_cond_last_tx ? dap_uint256_to_char(l_out_cond_last_tx->header.value, &l_amount_coins_str) : NULL;
- dap_string_append_printf(l_reply_str, "orderHash: %s\n ts_created: %s (%"DAP_UINT64_FORMAT_U")\n Status: %s, amount: %s (%s) %s, filled: %lu%%, rate (%s/%s): %s, net: %s\n\n", l_tx_hash_str,
- l_tmp_buf, l_ts_create, l_status_order,
+ dap_string_append_printf(l_reply_str, "orderHash: %s\n ts_created: %s\n Status: %s, amount: %s (%s) %s, filled: %lu%%, rate (%s/%s): %s, net: %s\n\n", l_tx_hash_str,
+ l_tmp_buf, l_status_order,
l_amount_coins_str ? l_amount_coins_str : "0.0",
l_amount_datoshi_str ? l_amount_datoshi_str : "0",
l_price->token_sell, l_percent_completed,
@@ -2428,12 +2422,11 @@ static int s_cli_srv_xchange(int a_argc, char **a_argv, void **a_str_reply)
char l_tmp_buf[DAP_TIME_STR_SIZE];
dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_last_rate_time);
- l_tmp_buf[strlen(l_tmp_buf) - 1] = '\0';
const char *l_rate_average_str; dap_uint256_to_char(l_rate_average, &l_rate_average_str);
- dap_string_append_printf(l_reply_str,"Average rate: %s \r\n", l_rate_average_str);
+ dap_string_append_printf(l_reply_str,"Average rate: %s\n", l_rate_average_str);
const char *l_last_rate_str; dap_uint256_to_char(l_rate, &l_last_rate_str);
- dap_string_append_printf(l_reply_str, "Last rate: %s Last rate time: %s (%"DAP_UINT64_FORMAT_U")",
- l_last_rate_str, l_tmp_buf, l_last_rate_time);
+ dap_string_append_printf(l_reply_str, "Last rate: %s Last rate time: %s",
+ l_last_rate_str, l_tmp_buf);
*a_str_reply = dap_string_free(l_reply_str, false);
break;
}else if (strcmp(l_price_subcommand,"history") == 0){
@@ -2453,7 +2446,7 @@ static int s_cli_srv_xchange(int a_argc, char **a_argv, void **a_str_reply)
size_t l_datum_num = dap_list_length(l_datum_list0);
if (l_datum_num == 0){
- dap_cli_server_cmd_set_reply_text(a_str_reply,"Can't find transactions");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find transactions");
return -6;
}
size_t l_arr_start = 0;
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 01a2468ff55625627c71735f8a5129ec0dd21d83..99ea171cf964f816ebdd3b85202419e11271e7f1 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -62,10 +62,12 @@ typedef struct dap_chain_cs_blocks_pvt
size_t forked_br_cnt;
dap_chain_block_forked_branch_t **forked_branches; // list of lists with atoms in side branches
+ pthread_rwlock_t forked_branches_rwlock;
// Chunks treshold
dap_chain_block_chunks_t * chunks;
dap_chain_block_datum_index_t *datum_index; // To find datum in blocks
+ pthread_rwlock_t datums_rwlock;
dap_chain_hash_fast_t genesis_block_hash;
dap_chain_hash_fast_t static_genesis_block_hash;
@@ -78,12 +80,24 @@ typedef struct dap_chain_cs_blocks_pvt
dap_timerfd_t *fill_timer;
uint64_t fill_timeout;
- pthread_rwlock_t rwlock, datums_rwlock;
+ pthread_rwlock_t rwlock;
struct cs_blocks_hal_item *hal;
} dap_chain_cs_blocks_pvt_t;
#define PVT(a) ((dap_chain_cs_blocks_pvt_t *)(a)->_pvt )
+#define print_rdlock(blocks) log_it(L_DEBUG, "Try to rdlock, %s, %d, thread_id=%u", __FUNCTION__, __LINE__, dap_gettid());\
+ pthread_rwlock_rdlock(& PVT(blocks)->rwlock);\
+ log_it(L_DEBUG, "Locked rdlock, %s, %d, thread_id=%u", __FUNCTION__, __LINE__, dap_gettid());
+
+#define print_wrlock(blocks) log_it(L_DEBUG, "Try to wrlock, %s, %d, thread_id=%u", __FUNCTION__, __LINE__, dap_gettid());\
+ pthread_rwlock_wrlock(& PVT(blocks)->rwlock);\
+ log_it(L_DEBUG, "Locked wrlock, %s, %d, thread_id=%u", __FUNCTION__, __LINE__, dap_gettid());
+
+#define print_unlock(blocks) log_it(L_DEBUG, "Try to unlock, %s, %d, thread_id=%u", __FUNCTION__, __LINE__, dap_gettid());\
+ pthread_rwlock_unlock(& PVT(blocks)->rwlock);\
+ log_it(L_DEBUG, "Unlocked rwqlock, %s, %d, thread_id=%u", __FUNCTION__, __LINE__, dap_gettid());
+
static int s_cli_parse_cmd_hash(char ** a_argv, int a_arg_index, int a_argc, void **a_str_reply,const char * a_param, dap_chain_hash_fast_t * a_datum_hash);
static void s_cli_meta_hash_print( json_object* json_obj_a, const char * a_meta_title, dap_chain_block_meta_t * a_meta);
static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply);
@@ -155,7 +169,7 @@ int dap_chain_cs_blocks_init()
{
dap_chain_cs_type_add("blocks", s_chain_cs_blocks_new);
s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
- s_debug_more = true; //dap_config_get_item_bool_default(g_config, "blocks", "debug_more", false);
+ s_debug_more = dap_config_get_item_bool_default(g_config, "blocks", "debug_more", false);
dap_cli_server_cmd_add ("block", s_cli_blocks, "Create and explore blockchains",
"New block create, fill and complete commands:\n"
"block -net <net_name> -chain <chain_name> new\n"
@@ -286,6 +300,7 @@ static int s_chain_cs_blocks_new(dap_chain_t *a_chain, dap_config_t *a_chain_con
l_cs_blocks->_pvt = l_cs_blocks_pvt;
pthread_rwlock_init(&l_cs_blocks_pvt->rwlock,NULL);
pthread_rwlock_init(&l_cs_blocks_pvt->datums_rwlock, NULL);
+ pthread_rwlock_init(&l_cs_blocks_pvt->forked_branches_rwlock, NULL);
const char * l_genesis_blocks_hash_str = dap_config_get_item_str_default(a_chain_config,"blocks","genesis_block",NULL);
if ( l_genesis_blocks_hash_str ){
@@ -527,8 +542,7 @@ static void s_print_autocollect_table(dap_chain_net_t *a_net, json_object* json_
static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
{
json_object **json_arr_reply = (json_object **)a_str_reply;
- //char ** a_str_reply = (char **) reply;
- const char *l_hash_out_type = NULL;
+ //char ** a_str_reply = (char **) reply;
enum {
SUBCMD_UNDEFINED =0,
SUBCMD_NEW_FLUSH,
@@ -1339,6 +1353,7 @@ static void s_callback_delete(dap_chain_t * a_chain)
pthread_rwlock_unlock(&PVT(l_blocks)->rwlock);
pthread_rwlock_destroy(&PVT(l_blocks)->rwlock);
pthread_rwlock_destroy(&PVT(l_blocks)->datums_rwlock);
+ pthread_rwlock_destroy(&PVT(l_blocks)->forked_branches_rwlock);
dap_chain_block_chunks_delete(PVT(l_blocks)->chunks);
DAP_DEL_Z(l_blocks->_inheritor);
DAP_DEL_Z(l_blocks->_pvt);
@@ -1348,6 +1363,19 @@ static void s_callback_delete(dap_chain_t * a_chain)
static void s_callback_cs_blocks_purge(dap_chain_t *a_chain)
{
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
+
+ pthread_rwlock_wrlock(&PVT(l_blocks)->forked_branches_rwlock);
+ for (size_t i = 0; i < PVT(l_blocks)->forked_br_cnt; i++){
+ dap_chain_block_forked_branch_atoms_table_t *l_atom_tmp, *l_atom;
+ HASH_ITER(hh, PVT(l_blocks)->forked_branches[i]->forked_branch_atoms, l_atom, l_atom_tmp) {
+ HASH_DEL(PVT(l_blocks)->forked_branches[i]->forked_branch_atoms, l_atom);
+ l_atom = NULL;
+ }
+ DAP_DEL_Z(PVT(l_blocks)->forked_branches[i]);
+ }
+ DAP_DEL_Z(PVT(l_blocks)->forked_branches);
+ pthread_rwlock_unlock(&PVT(l_blocks)->forked_branches_rwlock);
+
pthread_rwlock_wrlock(&PVT(l_blocks)->rwlock);
dap_chain_block_cache_t *l_block = NULL, *l_block_tmp = NULL;
HASH_ITER(hh, PVT(l_blocks)->blocks, l_block, l_block_tmp) {
@@ -1467,73 +1495,6 @@ static void s_add_atom_to_blocks(dap_chain_cs_blocks_t *a_blocks, dap_chain_bloc
}
-/**
- * @brief s_bft_consensus_setup
- * @param a_blocks
- */
-static void s_bft_consensus_setup(dap_chain_cs_blocks_t * a_blocks)
-{
- bool l_was_chunks_changed = false;
- // Compare all chunks with chain's tail
- for (dap_chain_block_chunk_t *l_chunk = PVT(a_blocks)->chunks->chunks_last ; l_chunk; l_chunk=l_chunk->prev ){
- size_t l_chunk_length = HASH_COUNT(l_chunk->block_cache_hash);
- dap_chain_block_cache_t * l_block_cache_chunk_top_prev = dap_chain_block_cache_get_by_hash(a_blocks,&l_chunk->block_cache_top->prev_hash);
- dap_chain_block_cache_t * l_block_cache= l_block_cache_chunk_top_prev;
- if ( l_block_cache ){ // we found prev block in main chain
- size_t l_tail_length = 0;
- // Now lets calc tail length
- for( ;l_block_cache; l_block_cache=l_block_cache->prev){
- l_tail_length++;
- if(l_tail_length>l_chunk_length)
- break;
- }
- if(l_tail_length<l_chunk_length ){ // This generals consensus is bigger than the current one
- // Cutoff current chank from the list
- if( l_chunk->next)
- l_chunk->next->prev = l_chunk->prev;
- if( l_chunk->prev)
- l_chunk->prev->next = l_chunk->next;
-
- // Pass through all the tail and move it to chunks
- for(l_block_cache= l_block_cache_chunk_top_prev ;l_block_cache; l_block_cache=l_block_cache->prev){
- pthread_rwlock_wrlock(& PVT(a_blocks)->rwlock);
- if(l_block_cache->prev)
- l_block_cache->prev->next = l_block_cache->next;
- if(l_block_cache->next)
- l_block_cache->next->prev = l_block_cache->prev;
- HASH_DEL(PVT(a_blocks)->blocks,l_block_cache);
- --PVT(a_blocks)->blocks_count;
- pthread_rwlock_unlock(& PVT(a_blocks)->rwlock);
- dap_chain_block_chunks_add(PVT(a_blocks)->chunks,l_block_cache);
- }
- // Pass through all the chunk and add it to main chain
- for(l_block_cache= l_chunk->block_cache_top ;l_block_cache; l_block_cache=l_block_cache->prev){
- int l_check_res = 0;
- if (a_blocks->callback_block_verify)
- l_check_res = a_blocks->callback_block_verify(a_blocks, l_block_cache->block, l_block_cache->block_size);
- if (!l_check_res) {
- log_it(L_WARNING,"Can't move block %s from chunk to main chain - data inside wasn't verified: code %d",
- l_block_cache->block_hash_str, l_check_res);
- dap_chain_block_chunks_add(PVT(a_blocks)->chunks,l_block_cache);
- }
- // TODO Rework blocks rwlock usage for this code
- HASH_ADD(hh, PVT(a_blocks)->blocks, block_hash, sizeof(l_block_cache->block_hash), l_block_cache);
- ++PVT(a_blocks)->blocks_count;
- s_add_atom_datums(a_blocks, l_block_cache);
- }
- dap_chain_block_chunk_delete(l_chunk );
- l_was_chunks_changed = true;
- }
- }
-
- }
- if(l_was_chunks_changed){
- dap_chain_block_chunks_sort( PVT(a_blocks)->chunks);
- log_it(L_INFO,"Recursive BFT stage additional check...");
- s_bft_consensus_setup(a_blocks);
- }
-}
-
static void s_select_longest_branch(dap_chain_cs_blocks_t * a_blocks, dap_chain_block_cache_t * a_bcache, uint64_t a_main_branch_length, dap_chain_cell_t *a_cell)
{
dap_chain_cs_blocks_t * l_blocks = a_blocks;
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index e7dca3dd963e765278675e9c9c3b75c31b72fbe5..d392889bb785d87e44c5b7c3f71066fad1856daa 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -150,11 +150,7 @@ int dap_chain_cs_dag_init()
s_debug_more = dap_config_get_item_bool_default(g_config, "dag", "debug_more", false);
s_threshold_enabled = dap_config_get_item_bool_default(g_config, "dag", "threshold_enabled",false);
debug_if(s_debug_more, L_DEBUG, "Thresholding %s", s_threshold_enabled ? "enabled" : "disabled");
- dap_cli_server_cmd_add ("dag", s_cli_dag, "DAG commands",
- "dag event create -net <net_name> -chain <chain_name> -datum <datum_hash> [-H {hex | base58(default)}]\n"
- "\tCreate event from datum mempool element\n\n"
- "dag event cancel -net <net_name> -chain <chain_name> -event <event_hash>\n"
- "\tRemove event from forming new round and put back its datum to mempool\n\n"
+ dap_cli_server_cmd_add ("dag", s_cli_dag, "DAG commands",
"dag event sign -net <net_name> -chain <chain_name> -event <event_hash>\n"
"\tAdd sign to event <event hash> in round.new. Hash doesn't include other signs so event hash\n"
"\tdoesn't changes after sign add to event. \n\n"
@@ -1329,9 +1325,8 @@ static dap_chain_datum_t *s_chain_callback_datum_iter_get_next(dap_chain_datum_i
*/
static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
{
+ json_object **json_arr_reply = (json_object **)a_str_reply;
enum {
- SUBCMD_EVENT_CREATE,
- SUBCMD_EVENT_CANCEL,
SUBCMD_EVENT_LIST,
SUBCMD_EVENT_DUMP,
SUBCMD_EVENT_SIGN,
@@ -1364,31 +1359,30 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
- return -1;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR,"invalid parameter -H, valid values: -H <hex | base58>");
+ return -DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR;
}
- dap_chain_node_cli_cmd_values_parse_net_chain(&arg_index, argc, argv, a_str_reply, &l_chain, &l_net,
- CHAIN_TYPE_INVALID);
+ if(dap_chain_node_cli_cmd_values_parse_net_chain_for_json(&arg_index, argc, argv, &l_chain, &l_net,CHAIN_TYPE_TX) < 0)
+ return -DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR;
+
if ((l_net == NULL) || (l_chain == NULL)){
return -1;
- } else if (a_str_reply && *a_str_reply) {
- DAP_DELETE(*a_str_reply);
- *a_str_reply = NULL;
- }
+ }
l_dag = DAP_CHAIN_CS_DAG(l_chain);
const char *l_chain_type = dap_chain_get_cs_type(l_chain);
if (!strstr(l_chain_type, "dag_")){
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Type of chain %s is not dag. This chain with type %s is not supported by this command",
- l_chain->name, l_chain_type);
- return -42;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_CHAIN_TYPE_ERR,"Type of chain %s is not dag. This chain with type %s is not supported by this command",
+ l_chain->name, l_chain_type);
+ return -DAP_CHAIN_NODE_CLI_COM_DAG_CHAIN_TYPE_ERR;
}
int ret = 0;
if ( l_round_cmd_str ) {
+ json_object * json_obj_round = json_object_new_object();
+ char l_buf[150] = {};
if ( strcmp(l_round_cmd_str,"complete") == 0 ){
const char * l_cmd_mode_str = NULL;
dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-mode", &l_cmd_mode_str);
@@ -1400,9 +1394,8 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
size_t l_objs_size=0;
dap_global_db_obj_t * l_objs = dap_global_db_get_all_sync(l_dag->gdb_group_events_round_new,&l_objs_size);
-
- dap_string_t *l_str_ret_tmp= l_objs_size>0 ? dap_string_new("Completing round:\n") : dap_string_new("Completing round: no data");
-
+ dap_string_t *l_str_ret_tmp= l_objs_size>0 ? json_object_object_add(json_obj_round,"round status", json_object_new_string("Completing round")):
+ json_object_object_add(json_obj_round,"round status", json_object_new_string("Completing round: no data"));
// list for verifed and added events
dap_list_t *l_list_to_del = NULL;
@@ -1416,25 +1409,26 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
size_t l_event_size = l_round_item->event_size;
dap_hash_fast(l_event, l_event_size, &l_event_hash);
int l_ret_event_verify;
- if ( ( l_ret_event_verify = l_dag->callback_cs_verify (l_dag,l_event,l_event_size) ) !=0 ){// if consensus accept the event
- dap_string_append_printf( l_str_ret_tmp,
- "Error! Event %s is not passing consensus verification, ret code %d\n",
+ if ( ( l_ret_event_verify = l_dag->callback_cs_verify (l_dag,l_event,l_event_size) ) !=0 ){// if consensus accept the event
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_EVENT_ERR,"Error! Event %s is not passing consensus verification, ret code %d\n",
l_objs[i].key, l_ret_event_verify );
- ret = -30;
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_EVENT_ERR;
break;
}else {
- dap_string_append_printf( l_str_ret_tmp, "Event %s verification passed\n", l_objs[i].key);
+ snprintf(l_buf, 150, "Event %s verification passed", l_objs[i].key);
+ json_object_object_add(json_obj_round,"verification status", json_object_new_string(l_buf));
// If not verify only mode we add
if ( ! l_verify_only ){
- if (s_chain_callback_atom_add(l_chain, l_event, l_event_size, &l_event_hash) != ATOM_ACCEPT) { // Add new atom in chain
- dap_string_append_printf(l_str_ret_tmp, "Event %s not added in chain\n", l_objs[i].key);
+ if (s_chain_callback_atom_add(l_chain, l_event, l_event_size, &l_event_hash)!= ATOM_ACCEPT) { // Add new atom in chain
+ snprintf(l_buf, 150, "Event %s not added in chain\n", l_objs[i].key);
+ json_object_object_add(json_obj_round,"status add", json_object_new_string(l_buf));
} else {
// add event to delete
l_list_to_del = dap_list_prepend(l_list_to_del, (void *)l_objs[i].key);
- dap_string_append_printf(l_str_ret_tmp, "Event %s added in chain successfully\n",
+ snprintf(l_buf, 150, "Event %s added in chain successfully\n",
l_objs[i].key);
+ json_object_object_add(json_obj_round,"status add", json_object_new_string(l_buf));
}
-
}
}
}
@@ -1453,7 +1447,7 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
// Cleaning up
dap_global_db_objs_delete(l_objs, l_objs_size);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_ret_tmp->str);
+ json_object_array_add(*json_arr_reply, json_obj_round);
dap_string_free(l_str_ret_tmp, true);
// Spread new mempool changes and dag events in network - going to SYNC_ALL
@@ -1469,20 +1463,20 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
l_datum_in_hash = dap_enc_base58_to_hex_str_from_str(l_datum_hash_str);
}
} else {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "The -datum option was not specified, so "
- "no datum is known to look for in rounds.\n");
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR,"The -datum option was not specified, so "
+ "no datum is known to look for in rounds.\n");
return 0;
}
dap_hash_fast_t l_datum_hash = {0};
dap_chain_hash_fast_from_str(l_datum_in_hash, &l_datum_hash);
if (dap_hash_fast_is_blank(&l_datum_hash)) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "The -datum parameter is not a valid hash.\n");
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR,"The -datum parameter is not a valid hash.\n");
return 0;
}
size_t l_objs_size = 0;
dap_global_db_obj_t * l_objs = dap_global_db_get_all_sync(l_dag->gdb_group_events_round_new, &l_objs_size);
size_t l_search_events = 0;
- dap_string_t *l_events_str = dap_string_new("Events: \n");
+ json_object_object_add(json_obj_round,"Events", json_object_new_string("empty"));
for (size_t i = 0; i < l_objs_size;i++) {
if (!strcmp(DAG_ROUND_CURRENT_KEY, l_objs[i].key))
continue;
@@ -1494,46 +1488,24 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
dap_hash_fast(l_event, l_event_size, &ll_event_hash);
char *ll_event_hash_str = dap_hash_fast_to_str_new(&ll_event_hash);
l_search_events++;
- dap_string_append_printf(l_events_str,
- "\t%zu) hash:%s cell_id:%zu\n", l_search_events, ll_event_hash_str,
- l_event->header.cell_id.uint64);
+ json_object_object_add(json_obj_round,"events count", json_object_new_uint64(l_search_events));
+ json_object_object_add(json_obj_round,"event hash", json_object_new_string(ll_event_hash_str));
+ json_object_object_add(json_obj_round,"cell_id", json_object_new_uint64(l_event->header.cell_id.uint64));
DAP_DELETE(ll_event_hash_str);
}
}
dap_global_db_objs_delete(l_objs, l_objs_size);
DAP_DELETE(l_datum_in_hash);
- if (l_search_events > 0) {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Datum with hash %s found in %zu events:\n%s\n", l_datum_hash_str,
- l_search_events, l_events_str->str);
- } else {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum hash %s not found in round event.\n", l_datum_hash_str);
- }
- dap_string_free(l_events_str, true);
+ if (!l_search_events) {
+ snprintf(l_buf, 150, "Datum hash %s not found in round event.\n", l_datum_hash_str);
+ json_object_object_add(json_obj_round,"find result", json_object_new_string(l_buf));
+ }
return 0;
}
- }else if ( l_event_cmd_str ) {
+ }else if ( l_event_cmd_str ) {
char *l_datum_hash_hex_str = NULL;
char *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);
-
- // datum hash may be in hex or base58 format
- if(l_datum_hash_str) {
- if(!dap_strncmp(l_datum_hash_str, "0x", 2) || !dap_strncmp(l_datum_hash_str, "0X", 2)) {
- l_datum_hash_hex_str = dap_strdup(l_datum_hash_str);
- l_datum_hash_base58_str = dap_enc_base58_from_hex_str_to_str(l_datum_hash_str);
- }
- else {
- l_datum_hash_hex_str = dap_enc_base58_to_hex_str_from_str(l_datum_hash_str);
- l_datum_hash_base58_str = dap_strdup(l_datum_hash_str);
- }
- }
- l_event_subcmd = SUBCMD_EVENT_CREATE;
- } else if ( strcmp( l_event_cmd_str, "cancel" ) == 0 ) {
- dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
- l_event_subcmd = SUBCMD_EVENT_CANCEL;
- } else if ( strcmp( l_event_cmd_str, "list" ) == 0 ) {
+ if ( strcmp( l_event_cmd_str, "list" ) == 0 ) {
l_event_subcmd = SUBCMD_EVENT_LIST;
dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-from", &l_from_events_str);
} else if ( strcmp( l_event_cmd_str,"dump") == 0 ) {
@@ -1566,95 +1538,11 @@ static int s_cli_dag(int argc, char ** argv, void **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: {
- 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_gdb_group_mempool, l_datum_hash_hex_str, &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_gdb_group_mempool, l_datum_hash_str)) {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "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 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);
- }
- ret = 0;
- } else {
- dap_chain_cs_dag_event_item_t * l_event_item = NULL;
- pthread_mutex_lock(&PVT(l_dag)->events_mutex);
- HASH_FIND(hh,PVT(l_dag)->events,&l_event_hash,sizeof(l_event_hash),l_event_item);
- pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
- if (l_event_item) {
- pthread_mutex_lock(&PVT(l_dag)->events_mutex);
- HASH_DELETE(hh, PVT(l_dag)->events, l_event_item);
- pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
- 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_net_sync_gdb(l_net);
- } break; /* SUBCMD_EVENT_CANCEL */
+ switch (l_event_subcmd) {
case SUBCMD_EVENT_DUMP: {
+ json_object * json_obj_event = json_object_new_object();
+ char l_buf[150] = {};
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;
@@ -1675,9 +1563,8 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
if ( l_event_item )
l_event = l_event_item->event;
else {
- ret = -23;
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't find event %s in events_last table\n", l_event_hash_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR,"Can't find event %s in events_last table\n", l_event_hash_str);
break;
}
} else if (!l_from_events_str || strcmp(l_from_events_str,"events") == 0) {
@@ -1689,9 +1576,8 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
l_event = l_event_item->event;
l_event_size = l_event_item->event_size;
} else {
- ret = -24;
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't find event %s in events table\n", l_event_hash_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR,"Can't find event %s in events table\n", l_event_hash_str);
break;
}
} else if (l_from_events_str && strcmp(l_from_events_str,"threshold") == 0) {
@@ -1702,50 +1588,49 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
if (l_event_item)
l_event = l_event_item->event;
else {
- ret = -23;
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't find event %s in threshold table\n", l_event_hash_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR,"Can't find event %s in threshold table\n", l_event_hash_str);
break;
}
} else {
- ret = -22;
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Wrong events_from option \"%s\", need one of variant: events, round.new, events_lasts, threshold", l_from_events_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR,
+ "Wrong events_from option \"%s\", need one of variant: events, round.new, events_lasts, threshold", l_from_events_str);
break;
}
- if ( l_event ){
- dap_string_t * l_str_tmp = dap_string_new(NULL);
- char buf[DAP_TIME_STR_SIZE];
-
- dap_string_append_printf(l_str_tmp,"\nEvent %s:\n", l_event_hash_str);
+ if ( l_event ){
+ json_object_object_add(json_obj_event,"Event hash", json_object_new_string(l_event_hash_str));
// Round info
if ((l_from_events_str && strcmp(l_from_events_str,"round.new") == 0) && l_round_item) {
- dap_string_append_printf(l_str_tmp,
- "\tRound info:\n\t\tsigns reject: %d\n",
- l_round_item->round_info.reject_count);
+ char buf[DAP_TIME_STR_SIZE];
+ json_object_object_add(json_obj_event,"Round info", json_object_new_string(" "));
+ json_object_object_add(json_obj_event,"tsigns reject", json_object_new_uint64(l_round_item->round_info.reject_count));
+ json_object_object_add(json_obj_event,"ts_update", json_object_new_string(buf));
dap_nanotime_to_str_rfc822(buf, DAP_TIME_STR_SIZE, l_round_item->round_info.ts_update);
- dap_string_append_printf(l_str_tmp, "\t\tdatum_hash: %s\n\t\tts_update: %s\n",
- dap_chain_hash_fast_to_str_static(&l_round_item->round_info.datum_hash), buf);
+ json_object_object_add(json_obj_event,"datum_hash", json_object_new_string(dap_chain_hash_fast_to_str_static(&l_round_item->round_info.datum_hash)));
+ json_object_object_add(json_obj_event,"ts_update", json_object_new_string(buf));
}
- // Header
- dap_string_append_printf(l_str_tmp,"\t\tHeader:\n");
- dap_string_append_printf(l_str_tmp,"\t\t\tversion: %hu\n",l_event->header.version);
- dap_string_append_printf(l_str_tmp,"\t\t\tround ID: %"DAP_UINT64_FORMAT_U"\n",l_event->header.round_id);
- dap_string_append_printf(l_str_tmp,"\t\t\tcell_id: 0x%016"DAP_UINT64_FORMAT_x"\n",l_event->header.cell_id.uint64);
- dap_string_append_printf(l_str_tmp,"\t\t\tchain_id: 0x%016"DAP_UINT64_FORMAT_X"\n",l_event->header.chain_id.uint64);
+ // Header
+ json_object_object_add(json_obj_event,"Header", json_object_new_string("empty"));
+ sprintf(l_buf,"%hu",l_event->header.version);
+ json_object_object_add(json_obj_event,"version", json_object_new_string(l_buf));
+ json_object_object_add(json_obj_event,"round ID", json_object_new_uint64(l_event->header.round_id));
+ sprintf(l_buf,"0x%016"DAP_UINT64_FORMAT_x"",l_event->header.cell_id.uint64);
+ json_object_object_add(json_obj_event,"cell_id", json_object_new_string(l_buf));
+ sprintf(l_buf,"0x%016"DAP_UINT64_FORMAT_x"",l_event->header.chain_id.uint64);
+ json_object_object_add(json_obj_event,"chain_id", json_object_new_string(l_buf));
dap_time_to_str_rfc822(buf, DAP_TIME_STR_SIZE, l_event->header.ts_created);
- dap_string_append_printf(l_str_tmp,"\t\t\tts_created: %s\n", buf );
+ json_object_object_add(json_obj_event,"ts_created", json_object_new_string(l_buf));
// Hash links
- dap_string_append_printf(l_str_tmp,"\t\t\thashes:\tcount: %u\n",l_event->header.hash_count);
+ json_object_object_add(json_obj_event,"hashes count", json_object_new_uint64(l_event->header.hash_count));
for (uint16_t i=0; i < l_event->header.hash_count; i++){
dap_chain_hash_fast_t * l_hash = (dap_chain_hash_fast_t *) (l_event->hashes_n_datum_n_signs +
i*sizeof (dap_chain_hash_fast_t));
- dap_string_append_printf(l_str_tmp,"\t\t\t\thash: %s\n",
- dap_chain_hash_fast_to_str_static(l_hash));
+ json_object_object_add(json_obj_event,"hash", json_object_new_string(dap_chain_hash_fast_to_str_static(l_hash)));
}
size_t l_offset = l_event->header.hash_count*sizeof (dap_chain_hash_fast_t);
dap_chain_datum_t * l_datum = (dap_chain_datum_t*) (l_event->hashes_n_datum_n_signs + l_offset);
@@ -1754,21 +1639,23 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
// Nested datum
const char *l_datum_type = NULL;
DAP_DATUM_TYPE_STR(l_datum->header.type_id, l_datum_type)
- dap_string_append_printf(l_str_tmp,"\t\tdatum:\tdatum_size: %zu\n",l_datum_size);
- dap_string_append_printf(l_str_tmp,"\t\t\tversion:=0x%02hhX\n", l_datum->header.version_id);
- dap_string_append_printf(l_str_tmp,"\t\t\ttype_id:=%s\n", l_datum_type);
+ json_object_object_add(json_obj_event,"Datum", json_object_new_string("empty"));
+ json_object_object_add(json_obj_event,"datum_size", json_object_new_uint64(l_datum_size));
+ sprintf(l_buf,"0x%02hhX",l_datum->header.version_id);
+ json_object_object_add(json_obj_event,"version", json_object_new_string(l_buf));
+ json_object_object_add(json_obj_event,"type_id", json_object_new_string(l_datum_type));
dap_time_to_str_rfc822(buf, DAP_TIME_STR_SIZE, l_datum->header.ts_create);
- dap_string_append_printf(l_str_tmp,"\t\t\tts_create=%s\n", buf);
- dap_string_append_printf(l_str_tmp,"\t\t\tdata_size=%u\n", l_datum->header.data_size);
-
+ json_object_object_add(json_obj_event,"ts_create", json_object_new_string(buf));
+ json_object_object_add(json_obj_event,"data_size", json_object_new_uint64(l_datum->header.data_size));
+
// Signatures
- dap_string_append_printf(l_str_tmp,"\t\t\t\tsigns:\tcount: %u\n",l_event->header.signs_count);
+ json_object_object_add(json_obj_event,"signs count", json_object_new_uint64(l_event->header.signs_count));
l_offset += l_datum_size;
while (l_offset + sizeof (l_event->header) < l_event_size ){
dap_sign_t * l_sign =(dap_sign_t *) (l_event->hashes_n_datum_n_signs +l_offset);
size_t l_sign_size = dap_sign_get_size(l_sign);
if (l_sign_size == 0 ){
- dap_string_append_printf(l_str_tmp,"\t\t\t\tERROR: wrong sign size 0, stop parsing headers\n");
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_SIGN_ERR," wrong sign size 0, stop parsing headers");
break;
}
dap_chain_hash_fast_t l_pkey_hash;
@@ -1777,19 +1664,17 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
? dap_enc_base58_encode_hash_to_str_static(&l_pkey_hash)
: dap_chain_hash_fast_to_str_static(&l_pkey_hash);
- dap_string_append_printf(l_str_tmp,"\t\t\t\t\t\ttype: %s\tpkey_hash: %s"
- "\n", dap_sign_type_to_str( l_sign->header.type ),
- l_hash_str );
+ json_object_object_add(json_obj_event,"type", json_object_new_string(dap_sign_type_to_str( l_sign->header.type )));
+ json_object_object_add(json_obj_event,"pkey_hash", json_object_new_string(l_hash_str));
+
l_offset += l_sign_size;
}
- dap_chain_datum_dump(l_str_tmp, l_datum, l_hash_out_type, l_net->pub.id);
+ dap_chain_datum_dump_json(json_obj_event, l_datum, l_hash_out_type, l_net->pub.id);
+ json_object_array_add(*json_arr_reply, json_obj_event);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_tmp->str);
- dap_string_free(l_str_tmp, true);
ret=0;
}else {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't find event 0x%s in the new forming round ",
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR,"Can't find event 0x%s in the new forming round ",
l_event_hash_str);
ret=-10;
}
@@ -1797,69 +1682,73 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
} break;
case SUBCMD_EVENT_LIST: {
+ json_object * json_obj_event_list = json_object_new_object();
+ json_object * json_arr_obj_event = json_object_new_array();
const char *l_limit_str = NULL, *l_offset_str = NULL;
dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-limit", &l_limit_str);
- dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-offset", &l_offset_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-offset", &l_offset_str);
+ char *ptr;
+ size_t l_limit = l_limit_str ? strtoull(l_limit_str, &ptr, 10) : 1000;
+ size_t l_offset = l_offset_str ? strtoull(l_offset_str, &ptr, 10) : 0;
+ if (l_offset)
+ json_object_object_add(json_obj_event_list,"offset", json_object_new_uint64(l_offset));
+ if (l_limit)
+ json_object_object_add(json_obj_event_list,"limit", json_object_new_uint64(l_limit));
+
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("");
if ( l_gdb_group_events ){
dap_global_db_obj_t * l_objs;
size_t l_objs_count = 0;
- l_objs = dap_global_db_get_all_sync(l_gdb_group_events,&l_objs_count);
- char *ptr;
- size_t l_limit = l_limit_str ? strtoull(l_limit_str, &ptr, 10) : 1000;
- size_t l_offset = l_offset_str ? strtoull(l_offset_str, &ptr, 10) : 0;
+ l_objs = dap_global_db_get_all_sync(l_gdb_group_events,&l_objs_count);
size_t l_arr_start = 0;
if (l_offset) {
- l_arr_start = l_offset;
- dap_string_append_printf(l_str_tmp, "offset: %lu\n", l_arr_start);
+ l_arr_start = l_offset;
}
size_t l_arr_end = l_objs_count;
if (l_limit) {
- dap_string_append_printf(l_str_tmp, "limit: %lu\n", l_limit);
l_arr_end = l_arr_start + l_limit;
if (l_arr_end > l_objs_count)
l_arr_end = l_objs_count;
}
- dap_string_append_printf(l_str_tmp,"%s.%s: Found %zu records :\n",l_net->pub.name,l_chain->name,l_objs_count);
+ json_object_object_add(json_obj_event_list,"net name", json_object_new_string(l_net->pub.name));
+ json_object_object_add(json_obj_event_list,"chain", json_object_new_string(l_chain->name));
+ json_object_object_add(json_obj_event_list,"obj count", json_object_new_uint64(l_objs_count));
for (size_t i = l_arr_start; i < l_arr_end; i++) {
+ json_object * json_obj_event_i = json_object_new_object();
if (!strcmp(DAG_ROUND_CURRENT_KEY, l_objs[i].key)) {
- dap_string_append_printf(l_str_tmp, "\t%s: %" DAP_UINT64_FORMAT_U "\n",
- l_objs[i].key, *(uint64_t *)l_objs[i].value);
+ json_object_object_add(json_obj_event_i, l_objs[i].key, json_object_new_uint64(*(uint64_t *)l_objs[i].value));
+ json_object_array_add(json_arr_obj_event, json_obj_event_i);
continue;
}
dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *)
((dap_chain_cs_dag_event_round_item_t *)l_objs[i].value)->event_n_signs;
char buf[DAP_TIME_STR_SIZE];
dap_time_to_str_rfc822(buf, DAP_TIME_STR_SIZE, l_event->header.ts_created);
- dap_string_append_printf(l_str_tmp, "\t%zu\t - %s: ts_create=%s\n", i - 1, l_objs[i].key, buf);
-
+ json_object_object_add(json_obj_event_i, "#", json_object_new_string(dap_itoa(i-1)));
+ json_object_object_add(json_obj_event_i, "obj key", json_object_new_string(l_objs[i].key));
+ json_object_object_add(json_obj_event_i, "ts_create", json_object_new_string(buf));
+ json_object_array_add(json_arr_obj_event, json_obj_event_i);
}
+ json_object_object_add(json_obj_event_list, "OBJ", json_arr_obj_event);
if (l_objs && l_objs_count )
dap_global_db_objs_delete(l_objs, l_objs_count);
ret = 0;
} else {
- dap_string_append_printf(l_str_tmp, "%s.%s: Error! No GlobalDB group!\n", l_net->pub.name, l_chain->name);
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_GLOBALDB_ERR, "%s.%s: Error! No GlobalDB group!\n", l_net->pub.name, l_chain->name);
ret = -2;
}
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_tmp->str);
- dap_string_free(l_str_tmp, true);
+ json_object_array_add(*json_arr_reply, json_obj_event_list);
} else if (!l_from_events_str || (strcmp(l_from_events_str,"events") == 0)) {
- dap_string_t * l_str_tmp = dap_string_new(NULL);
- pthread_mutex_lock(&PVT(l_dag)->events_mutex);
- size_t l_limit = l_limit_str ? strtoul(l_limit_str, NULL, 10) : 1000;
- size_t l_offset = l_offset_str ? strtoul(l_offset_str, NULL, 10) : 0;
+ pthread_mutex_lock(&PVT(l_dag)->events_mutex);
size_t l_arr_start = 0;
if (l_offset > 0) {
- l_arr_start = l_offset;
- dap_string_append_printf(l_str_tmp, "offset: %lu\n", l_arr_start);
+ l_arr_start = l_offset;
}
size_t l_arr_end = HASH_COUNT(PVT(l_dag)->events);
if (l_limit) {
- dap_string_append_printf(l_str_tmp, "limit: %lu\n", l_limit);
l_arr_end = l_arr_start + l_limit;
if (l_arr_end > HASH_COUNT(PVT(l_dag)->events))
l_arr_end = HASH_COUNT(PVT(l_dag)->events);
@@ -1870,83 +1759,89 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
if (i_tmp < l_arr_start || i_tmp >= l_arr_end) {
i_tmp++;
} else {
+ json_object * json_obj_event_i = json_object_new_object();
i_tmp++;
char buf[DAP_TIME_STR_SIZE];
dap_time_to_str_rfc822(buf, DAP_TIME_STR_SIZE, l_event_item->event->header.ts_created);
- dap_string_append_printf(l_str_tmp, "\t%zu\t- %s: ts_create=%s\n", i_tmp,
- dap_chain_hash_fast_to_str_static(&l_event_item->hash),
- buf);
+ json_object_object_add(json_obj_event_i, "#", json_object_new_string(dap_itoa(i_tmp)));
+ json_object_object_add(json_obj_event_i, "hash", json_object_new_string(dap_chain_hash_fast_to_str_static(&l_event_item->hash)));
+ json_object_object_add(json_obj_event_i, "ts_create", json_object_new_string(buf));
+ json_object_array_add(json_arr_obj_event, json_obj_event_i);
}
}
+ json_object_object_add(json_obj_event_list, "EVENTS", json_arr_obj_event);
size_t l_events_count = HASH_COUNT(PVT(l_dag)->events);
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
- dap_string_append_printf(l_str_tmp,"%s.%s have total %zu events :\n",
- l_net->pub.name, l_chain->name, l_events_count);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_tmp->str);
- dap_string_free(l_str_tmp, true);
- }else if (l_from_events_str && (strcmp(l_from_events_str,"threshold") == 0) ){
- dap_string_t * l_str_tmp = dap_string_new(NULL);
+
+ json_object_object_add(json_obj_event_list,"net name", json_object_new_string(l_net->pub.name));
+ json_object_object_add(json_obj_event_list,"chain", json_object_new_string(l_chain->name));
+ json_object_object_add(json_obj_event_list,"total events", json_object_new_uint64(l_events_count));
+
+ json_object_array_add(*json_arr_reply, json_obj_event_list);
+ }else if (l_from_events_str && (strcmp(l_from_events_str,"threshold") == 0) ){
pthread_mutex_lock(&PVT(l_dag)->events_mutex);
dap_chain_cs_dag_event_item_t * l_event_item = NULL,*l_event_item_tmp = NULL;
- size_t l_limit = l_limit_str ? strtoul(l_limit_str, NULL, 10) : 0;
- size_t l_offset = l_offset_str ? strtoul(l_offset_str, NULL, 10) : 0;
size_t l_arr_start = 0;
if (l_offset) {
l_arr_start = l_offset;
- dap_string_append_printf(l_str_tmp, "offset: %lu\n", l_arr_start);
}
size_t l_arr_end = HASH_COUNT(PVT(l_dag)->events_treshold);
if (l_limit) {
- dap_string_append_printf(l_str_tmp, "limit: %lu\n", l_limit);
l_arr_end = l_arr_start + l_limit;
if (l_arr_end > HASH_COUNT(PVT(l_dag)->events_treshold))
l_arr_end = HASH_COUNT(PVT(l_dag)->events_treshold);
}
size_t i_tmp = 0;
- dap_string_append_printf(l_str_tmp,"\nDAG threshold events:\n");
HASH_ITER(hh,PVT(l_dag)->events_treshold,l_event_item, l_event_item_tmp ) {
if (i_tmp < l_arr_start || i_tmp > l_arr_end) {
i_tmp++;
continue;
}
i_tmp++;
+ json_object * json_obj_event_i = json_object_new_object();
char buf[DAP_TIME_STR_SIZE];
dap_time_to_str_rfc822(buf, DAP_TIME_STR_SIZE, l_event_item->event->header.ts_created);
- dap_string_append_printf(l_str_tmp, "\t%zu\t- %s: ts_create=%s\n", i_tmp,
- dap_chain_hash_fast_to_str_static( &l_event_item->hash),
- buf);
+ json_object_object_add(json_obj_event_i, "#", json_object_new_string(dap_itoa(i_tmp)));
+ json_object_object_add(json_obj_event_i, "hash", json_object_new_string(dap_chain_hash_fast_to_str_static(&l_event_item->hash)));
+ json_object_object_add(json_obj_event_i, "ts_create", json_object_new_string(buf));
+ json_object_array_add(json_arr_obj_event, json_obj_event_i);
}
+ json_object_object_add(json_obj_event_list, "TRESHOLD", json_arr_obj_event);
size_t l_events_count = HASH_COUNT(PVT(l_dag)->events_treshold);
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
- dap_string_append_printf(l_str_tmp,"%s.%s have total %zu events in threshold :\n",
- l_net->pub.name, l_chain->name, l_events_count);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_tmp->str);
- dap_string_free(l_str_tmp, true);
+ json_object_object_add(json_obj_event_list,"net name", json_object_new_string(l_net->pub.name));
+ json_object_object_add(json_obj_event_list,"chain", json_object_new_string(l_chain->name));
+ json_object_object_add(json_obj_event_list,"total events", json_object_new_uint64(l_events_count));
+
+ json_object_array_add(*json_arr_reply, json_obj_event_list);
}else {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Undefined events source for listing ");
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_UNDEF_ERR, "Undefined events source for listing ");
ret=-14;
}
} break;
case SUBCMD_EVENT_COUNT: {
- dap_string_t *l_ret_str = dap_string_new(NULL);
- dap_string_append_printf(l_ret_str, "%s.%s:\n", l_net->pub.name, l_chain->name);
+ json_object * json_obj_event_count = json_object_new_object();
+ json_object_object_add(json_obj_event_count,"net name", json_object_new_string(l_net->pub.name));
+ json_object_object_add(json_obj_event_count,"chain", json_object_new_string(l_chain->name));
const char * l_gdb_group_events = DAP_CHAIN_CS_DAG(l_chain)->gdb_group_events_round_new;
if (l_gdb_group_events) {
size_t l_objs_count = 0;
dap_global_db_obj_t *l_objs = dap_global_db_get_all_sync(l_gdb_group_events,&l_objs_count);
- dap_string_append_printf(l_ret_str,"%zu in round.new\n", l_objs_count);
+ json_object_object_add(json_obj_event_count,"event count in round new", json_object_new_string(l_objs_count));
}
size_t l_event_count = HASH_COUNT(PVT(l_dag)->events);
size_t l_event_treshold_count = HASH_COUNT(PVT(l_dag)->events_treshold);
- dap_string_append_printf(l_ret_str, "%zu atom(s) in events\n%zu atom(s) in threshold", l_event_count, l_event_treshold_count);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_ret_str->str);
- dap_string_free(l_ret_str, true);
+ json_object_object_add(json_obj_event_count,"atom in events", json_object_new_uint64(l_event_count));
+ json_object_object_add(json_obj_event_count,"atom in threshold", json_object_new_uint64(l_event_treshold_count));
+ json_object_array_add(*json_arr_reply, json_obj_event_count);
} break;
case SUBCMD_EVENT_SIGN: { // Sign event command
+ json_object * json_obj_event_count = json_object_new_object();
+ json_object * json_arr_obj_event = json_object_new_array();
char * l_gdb_group_events = l_dag->gdb_group_events_round_new;
size_t l_round_item_size = 0;
dap_chain_cs_dag_event_round_item_t *l_round_item =
@@ -1968,42 +1863,44 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
if (dap_chain_cs_dag_event_gdb_set(l_dag, l_event_new_hash_hex_str, l_event,
l_event_size_new, l_round_item)) {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Added new sign with cert \"%s\", event %s placed back in round.new\n",
- l_cert_str, l_event_new_hash_base58_str ?
- l_event_new_hash_base58_str : l_event_new_hash_hex_str);
+ json_object * json_obj_sign = json_object_new_object();
+
+ json_object_object_add(json_obj_sign,"cert", json_object_new_string(l_cert_str));
+ json_object_object_add(json_obj_sign,"event", l_event_new_hash_base58_str ?
+ json_object_new_string(l_event_new_hash_base58_str) :
+ json_object_new_string(l_event_new_hash_hex_str));
+ json_object_array_add(json_arr_obj_event, json_obj_sign);
+
+ json_object_object_add(json_obj_event_count,"Added new sign with cert, event placed back in round.new", json_arr_obj_event);
+ json_object_array_add(*json_arr_reply, json_obj_event_count);
+
} else {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "GDB Error: Can't place event %s with new sign back in round.new\n",
- l_event_new_hash_base58_str ? l_event_new_hash_base58_str : l_event_new_hash_hex_str);
- ret = -31;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_SIGN_ERR,"GDB Error: Can't place event %s with new sign back in round.new\n",
+ l_event_new_hash_base58_str ? l_event_new_hash_base58_str : l_event_new_hash_hex_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_SIGN_ERR;
}
DAP_DELETE(l_event);
} else {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Can't sign event %s in round.new\n",
- l_event_hash_str);
- ret=-1;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_SIGN_ERR,"Can't sign event %s in round.new\n",
+ l_event_hash_str);
+ ret=-DAP_CHAIN_NODE_CLI_COM_DAG_SIGN_ERR;
}
} else {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "No valid certificate provided for event %s signing\n",
- l_event_hash_str);
- ret = -50;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_CERT_ERR,"No valid certificate provided for event %s signing\n",
+ l_event_hash_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_CERT_ERR;
}
DAP_DELETE(l_round_item);
} else {
- dap_cli_server_cmd_set_reply_text(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;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_FIND_EVENT_ERR,"Can't find event %s in round.new - only place where could be signed the new event\n",
+ l_event_hash_str);
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_FIND_EVENT_ERR;
}
} break;
case SUBCMD_UNDEFINED: {
- dap_cli_server_cmd_set_reply_text(a_str_reply,
- "Undefined event subcommand \"%s\" ",
- l_event_cmd_str);
- ret=-11;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_UNKNOWN,"Undefined event subcommand \"%s\" ",
+ l_event_cmd_str);
+ ret=-DAP_CHAIN_NODE_CLI_COM_DAG_UNKNOWN;
}
}
DAP_DEL_Z(l_datum_hash_hex_str);
@@ -2011,9 +1908,8 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
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;
+ dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_DAG_UNDEF_SUB_ERR,"Undefined subcommand");
+ ret = -DAP_CHAIN_NODE_CLI_COM_DAG_UNDEF_SUB_ERR;
}
return ret;
}
diff --git a/modules/type/dag/include/dap_chain_cs_dag.h b/modules/type/dag/include/dap_chain_cs_dag.h
index 68d154e2d79705146d0d902f275b4f292c77e92a..0043a3afbe2f1c151a2c3e558275ff9f0687403b 100644
--- a/modules/type/dag/include/dap_chain_cs_dag.h
+++ b/modules/type/dag/include/dap_chain_cs_dag.h
@@ -74,6 +74,25 @@ typedef struct dap_chain_cs_dag
void * _inheritor;
} dap_chain_cs_dag_t;
+typedef enum s_com_dag_err{
+ DAP_CHAIN_NODE_CLI_COM_DAG_OK = 0,
+ DAP_CHAIN_NODE_CLI_COM_DAG_PARAM_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_CHAIN_TYPE_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_DATUM_DEL_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_EVENT_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_SIGN_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_FIND_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_GLOBALDB_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_UNDEF_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_CERT_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_FIND_EVENT_ERR,
+ DAP_CHAIN_NODE_CLI_COM_DAG_UNDEF_SUB_ERR,
+
+ /* add custom codes here */
+
+ DAP_CHAIN_NODE_CLI_COM_DAG_UNKNOWN /* MAX */
+} s_com_dag_err_t;
+
#define DAP_CHAIN_CS_DAG(a) ( (dap_chain_cs_dag_t *) (a)->_inheritor)
int dap_chain_cs_dag_init();