diff --git a/CMakeLists.txt b/CMakeLists.txt
index 87f693ce8f15040dec97208f3d0ec55173b55224..a7a98f61469e8f8fcd5b097ead26a764fba887cf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@ endif()
if(NOT DEFINED CELLFRAME_MODULES)
include (dap-sdk/cmake/OS_Detection.cmake)
- set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-esbocs cs-none srv-app srv-app-db srv-datum srv-stake srv-voting srv-bridge srv-xchange")
+ set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-block-pos cs-esbocs cs-none srv-app srv-app-db srv-datum srv-stake srv-voting srv-bridge srv-xchange")
if(LINUX OR DARWIN)
set(CELLFRAME_MODULES "${CELLFRAME_MODULES} srv-vpn")
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 3b4079665a1c524cb670301839d79682a042ca25..b177cae7600f4d7ac61547dded161a7437ab548e 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -49,11 +49,6 @@ if (CELLFRAME_MODULES MATCHES "cs-dag-poa")
add_subdirectory(consensus/dag-poa)
endif()
-# DAG PoS
-if (CELLFRAME_MODULES MATCHES "cs-dag-pos")
- add_subdirectory(consensus/dag-pos)
-endif()
-
# Consensus type blocks
if (CELLFRAME_MODULES MATCHES "cs-block-")
add_subdirectory(type/blocks)
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index 11f1cb0ac4b143b835bb8a303eceefd4e1028e26..2fec03b9320c1ed8d781fc2adfbdcd6e7342ce50 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -85,7 +85,7 @@ static void s_callback_delete(dap_chain_cs_dag_t * a_dag);
static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg);
static void s_poa_round_clean(void *a_arg);
static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_cfg);
-static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_event_t * a_dag_event, size_t a_dag_event_size);
+static int s_callback_event_verify(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_dag_event, dap_hash_fast_t *a_event_hash);
static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a_dag, dap_chain_datum_t * a_datum,
dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count, size_t* a_event_size);
static bool s_callback_round_event_to_chain(struct round_timer_arg *a_arg);
@@ -100,6 +100,7 @@ static int s_cli_dag_poa(int argc, char ** argv, void **a_str_reply);
static bool s_seed_mode = false;
static dap_interval_timer_t s_poa_round_timer = NULL;
+static bool s_debug_more = false;
/**
* @brief
@@ -115,7 +116,7 @@ int dap_chain_cs_dag_poa_init()
dap_cli_server_cmd_add ("dag_poa", s_cli_dag_poa, "DAG PoA commands",
"dag_poa event sign -net <net_name> [-chain <chain_name>] -event <event_hash> [-H {hex | base58(default)}]\n"
"\tSign event <event hash> in the new round pool with its authorize certificate\n\n");
-
+ s_debug_more = dap_config_get_item_bool_default(g_config, "dag", "debug_more", s_debug_more);
return 0;
}
@@ -492,7 +493,9 @@ static bool s_round_event_ready_minimum_check(dap_chain_cs_dag_t *a_dag, dap_cha
a_event_hash_hex_str, a_event->header.signs_count, l_poa_pvt->auth_certs_count_verify);
return false;
}
- int l_ret_event_verify = s_callback_event_verify(a_dag, a_event, a_event_size);
+ dap_hash_fast_t l_event_hash;
+ dap_chain_hash_fast_from_hex_str(a_event_hash_hex_str, &l_event_hash);
+ int l_ret_event_verify = s_callback_event_verify(a_dag, a_event, &l_event_hash);
if (l_ret_event_verify == 0)
return true;
log_it(L_ERROR, "Round auto-complete error! Event %s is not passing consensus verification, ret code %d\n",
@@ -926,45 +929,30 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
* @param a_dag_event_size size_t size of event object
* @return int
*/
-static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_event_t * a_event, size_t a_event_size)
+static int s_callback_event_verify(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_event, dap_hash_fast_t *a_event_hash)
{
-
- dap_chain_cs_dag_poa_pvt_t * l_poa_pvt = PVT ( DAP_CHAIN_CS_DAG_POA( a_dag ) );
- size_t l_offset_from_beginning = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, a_event_size);
- if( l_offset_from_beginning >= a_event_size){
- log_it(L_WARNING,"Incorrect size with event %p: caled size excl signs %zd is bigger or equal then event size %zd",
- a_event, l_offset_from_beginning, a_event_size);
- return -7; // Incorrest size
- }
+ dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT ( DAP_CHAIN_CS_DAG_POA( a_dag ) );
+ size_t l_offset_from_beginning = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, 0);
+ size_t l_event_size = dap_chain_cs_dag_event_calc_size(a_event, 0);
uint16_t l_certs_count_verify = l_poa_pvt->auth_certs_count_verify;
- if (a_event->header.signs_count >= l_certs_count_verify) {
- size_t l_signs_count = 0;
- dap_sign_t **l_signs = dap_sign_get_unique_signs(((uint8_t*)a_event)+l_offset_from_beginning,
- a_event_size-l_offset_from_beginning, &l_signs_count);
-
- if (!l_signs_count){
- log_it(L_ERROR, "No any signatures at all for event");
- DAP_DELETE(l_signs);
- return -2;
- }
-
- if ( l_signs_count < l_certs_count_verify ) {
- log_it(L_ERROR, "Corrupted event: not enough signs: %zu of %hu", l_signs_count, l_certs_count_verify);
- DAP_DELETE(l_signs);
- return -1;
- }
-
- uint16_t l_signs_verified_count = 0;
- int l_ret = 0;
+ if (a_event->header.signs_count < l_certs_count_verify) {
+ log_it(L_WARNING, "Wrong signatures number %hu with event %s", a_event->header.signs_count,
+ dap_hash_fast_to_str_static(a_event_hash));
+ return -2; // Wrong signatures number
+ }
+ size_t l_signs_count = a_event->header.signs_count;
+ dap_sign_t **l_signs = dap_sign_get_unique_signs((uint8_t *)a_event + l_offset_from_beginning,
+ l_event_size - l_offset_from_beginning, &l_signs_count);
+ if (!l_signs_count) {
+ log_it(L_ERROR, "No any signatures at all for event");
+ DAP_DELETE(l_signs);
+ return -3;
+ }
+ uint16_t l_signs_verified_count = 0;
+ if (l_signs_count >= l_certs_count_verify) {
uint16_t l_event_signs_count = a_event->header.signs_count;
- for (size_t i=0; i<l_signs_count; i++) {
+ for (size_t i = 0; i < l_signs_count; i++) {
dap_sign_t *l_sign = (dap_sign_t *)l_signs[i];
- if (!dap_sign_verify_size(l_sign, a_event_size - l_offset_from_beginning)) {
- log_it(L_WARNING,"Incorrect size with event %p", a_event);
- l_ret = -3;
- break;
- }
-
// Compare signature with auth_certs
a_event->header.signs_count = i;
for (uint16_t j = 0; j < l_poa_pvt->auth_certs_count; j++) {
@@ -977,31 +965,14 @@ static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_
}
a_event->header.signs_count = l_event_signs_count;
DAP_DELETE(l_signs);
- if (l_signs_verified_count < l_certs_count_verify) {
- dap_hash_fast_t l_event_hash;
- dap_hash_fast(a_event, a_event_size, &l_event_hash);
- char l_event_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_hash_fast_to_str(&l_event_hash, l_event_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
- log_it(L_ERROR, "Corrupted event %s, not enough signs %hu from %hu",
- l_event_hash_str, l_signs_verified_count, l_certs_count_verify);
- return l_ret ? l_ret : -4;
- }
- return 0;
- }
- else if (a_event->header.hash_count == 0){
- dap_chain_hash_fast_t l_event_hash;
- dap_chain_cs_dag_event_calc_hash(a_event,a_event_size, &l_event_hash);
- if ( memcmp( &l_event_hash, &a_dag->static_genesis_event_hash, sizeof(l_event_hash) ) == 0 ){
+ if (l_signs_verified_count >= l_certs_count_verify)
return 0;
- }else{
- log_it(L_WARNING,"Wrong genesis event %p: hash is not equels to what in config", a_event);
- return -20; // Wrong signatures number
- }
- }
- else{
- log_it(L_WARNING,"Wrong signatures number with event %p", a_event);
- return -2; // Wrong signatures number
}
+ debug_if(s_debug_more, L_ERROR, "Event %s, not enough signs %hu from %hu",
+ dap_hash_fast_to_str_static(a_event_hash),
+ l_signs_count >= l_certs_count_verify ? l_signs_verified_count : (uint16_t)l_signs_count,
+ l_certs_count_verify);
+ return -4;
}
dap_list_t *dap_chain_cs_dag_poa_get_auth_certs(dap_chain_t *a_chain, size_t *a_auth_certs_count, uint16_t *a_count_verify)
diff --git a/modules/consensus/dag-pos/CMakeLists.txt b/modules/consensus/dag-pos/CMakeLists.txt
deleted file mode 100644
index fd5b077250fb91362675f0fd85369ea739b8cc44..0000000000000000000000000000000000000000
--- a/modules/consensus/dag-pos/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project (dap_chain_cs_dag_pos)
-
-file(GLOB DAP_CHAIN_CS_DAG_POS_SRCS *.c)
-file(GLOB DAP_CHAIN_CS_DAG_POS_HEADERS include/*.h)
-
-add_library(${PROJECT_NAME} STATIC ${DAP_CHAIN_CS_DAG_POS_SRCS} ${DAP_CHAIN_CS_DAG_POS_HEADERS})
-
-target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_chain dap_chain_cs_dag dap_chain_net_srv_stake)
-target_include_directories(${PROJECT_NAME} INTERFACE .)
-target_include_directories(${PROJECT_NAME} PUBLIC include)
-
-if (INSTALL_SDK)
-set_target_properties(${PROJECT_NAME} PROPERTIES PUBLIC_HEADER "${DAP_CHAIN_CS_DAG_POS_HEADERS}")
-INSTALL(TARGETS ${PROJECT_NAME}
- LIBRARY DESTINATION lib/modules/consensus/dag-pos/
- ARCHIVE DESTINATION lib/modules/consensus/dag-pos/
- PUBLIC_HEADER DESTINATION include/modules/consensus/dag-pos/
- )
-endif()
\ No newline at end of file
diff --git a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c b/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
deleted file mode 100644
index 33911b5a9683b2fdb1cba03e8610c58c3e2a16d0..0000000000000000000000000000000000000000
--- a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Authors:
- * Dmitriy A. Gearasimov <gerasimov.dmitriy@demlabs.net>
- * DeM Labs Inc. https://demlabs.net
- * Kelvin Project https://github.com/kelvinblockchain
- * Copyright (c) 2017-2019
- * All rights reserved.
-
- This file is part of DAP (Distributed Applications Platform) the open source project
-
- DAP (Distributed Applications Platform) is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- DAP is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
-*/
-#include <stdlib.h>
-
-#include "dap_chain_net.h"
-#include "dap_common.h"
-#include "dap_string.h"
-#include "dap_strfuncs.h"
-#include "dap_chain_cell.h"
-#include "dap_chain_cs.h"
-#include "dap_chain_cs_dag.h"
-#include "dap_chain_cs_dag_pos.h"
-#include "dap_chain_net_srv_stake_pos_delegate.h"
-#include "dap_chain_ledger.h"
-
-#define LOG_TAG "dap_chain_cs_dag_pos"
-
-typedef struct dap_chain_cs_dag_pos_pvt
-{
- dap_enc_key_t *events_sign_key;
- char ** tokens_hold;
- uint64_t * tokens_hold_value;
- size_t tokens_hold_size;
- uint16_t confirmations_minimum;
-} dap_chain_cs_dag_pos_pvt_t;
-
-#define PVT(a) ((dap_chain_cs_dag_pos_pvt_t *) a->_pvt )
-
-static void s_callback_delete(dap_chain_cs_dag_t * a_dag);
-static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg);
-static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_cfg);
-static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_event_t * a_dag_event, size_t a_dag_event_size);
-static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a_dag, dap_chain_datum_t * a_datum,
- dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count, size_t *a_dag_event_size);
-
-/**
- * @brief dap_chain_cs_dag_pos_init
- * @return
- */
-int dap_chain_cs_dag_pos_init()
-{
- dap_chain_cs_add ("dag_pos", s_callback_new );
- return 0;
-}
-
-/**
- * @brief dap_chain_cs_dag_pos_deinit
- */
-void dap_chain_cs_dag_pos_deinit(void)
-{
-
-}
-
-/**
- * @brief s_cs_callback
- * @param a_chain
- * @param a_chain_cfg
- */
-static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
-{
- dap_chain_cs_type_create("dag", a_chain, a_chain_cfg);
- dap_chain_cs_dag_t *l_dag = DAP_CHAIN_CS_DAG ( a_chain );
- dap_chain_cs_dag_pos_t *l_pos = DAP_NEW_Z( dap_chain_cs_dag_pos_t);
- if (!l_pos) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return -1;
- }
-
- char ** l_tokens_hold = NULL;
- char ** l_tokens_hold_value_str = NULL;
- uint16_t l_tokens_hold_size = 0;
- uint16_t l_tokens_hold_value_size = 0;
-
- l_dag->_inheritor = l_pos;
- l_dag->callback_delete = s_callback_delete;
- l_dag->callback_cs_verify = s_callback_event_verify;
- l_dag->callback_cs_event_create = s_callback_event_create;
- l_pos->_pvt = DAP_NEW_Z(dap_chain_cs_dag_pos_pvt_t);
- dap_chain_cs_dag_pos_pvt_t *l_pos_pvt = PVT(l_pos);
- if (!l_pos_pvt) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- goto lb_err;
- }
-
- l_tokens_hold = dap_config_get_array_str( a_chain_cfg,"dag-pos","tokens_hold",&l_tokens_hold_size);
- l_tokens_hold_value_str = dap_config_get_array_str( a_chain_cfg,"dag-pos","tokens_hold_value",&l_tokens_hold_value_size);
-
- if ( l_tokens_hold_size != l_tokens_hold_value_size ){
- log_it(L_CRITICAL, "Entries tokens_hold and tokens_hold_value are different size!");
- goto lb_err;
- }
- l_pos_pvt->confirmations_minimum = dap_config_get_item_uint16_default( a_chain_cfg,"dag-pos","confirmations_minimum",1);
- l_pos_pvt->tokens_hold_size = l_tokens_hold_size;
- l_pos_pvt->tokens_hold = DAP_NEW_Z_SIZE( char*, sizeof(char*) *
- l_tokens_hold_size );
- if (!l_pos_pvt->tokens_hold) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- goto lb_err;
- }
- l_pos_pvt->tokens_hold_value = DAP_NEW_Z_SIZE(uint64_t,
- (l_tokens_hold_value_size +1) *sizeof (uint64_t));
- if (!l_pos_pvt->tokens_hold_value) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- goto lb_err;
- }
- for (size_t i = 0; i < l_tokens_hold_value_size; i++){
- l_pos_pvt->tokens_hold[i] = dap_strdup( l_tokens_hold[i] );
- if ( ( l_pos_pvt->tokens_hold_value[i] =
- strtoull(l_tokens_hold_value_str[i],NULL,10) ) == 0 ) {
- log_it(L_CRITICAL, "Token %s has inproper hold value %"DAP_UINT64_FORMAT_U, l_pos_pvt->tokens_hold[i],
- l_pos_pvt->tokens_hold_value[i] );
- goto lb_err;
- }
- }
- l_dag->chain->callback_created = s_callback_created;
- return 0;
-
-lb_err:
- for (int i = 0; i < l_tokens_hold_size; i++) {
- if (l_tokens_hold[i])
- DAP_DELETE(l_tokens_hold[i]);
- }
- if (l_tokens_hold)
- DAP_DELETE(l_tokens_hold);
- if (l_pos_pvt->tokens_hold_value)
- DAP_DELETE(l_pos_pvt->tokens_hold_value);
- if (l_pos_pvt)
- DAP_DELETE(l_pos_pvt);
- if (l_pos)
- DAP_DELETE(l_pos);
- l_dag->_inheritor = NULL;
- l_dag->callback_delete = NULL;
- l_dag->callback_cs_verify = NULL;
- return -1;
-
-}
-
-/**
- * @brief s_callback_created
- * @param a_chain
- * @param a_chain_cfg
- * @return
- */
-static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_net_cfg)
-{
- dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG ( a_chain );
- dap_chain_cs_dag_pos_t * l_pos = DAP_CHAIN_CS_DAG_POS( l_dag );
-
- const char * l_sign_cert_str = NULL;
- if ((l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg, "dag-pos", "events-sign-cert")) != NULL) {
- dap_cert_t *l_sign_cert = dap_cert_find_by_name(l_sign_cert_str);
- if (l_sign_cert == NULL) {
- log_it(L_ERROR, "Can't load sign certificate, name \"%s\" is wrong", l_sign_cert_str);
- } else if (l_sign_cert->enc_key->priv_key_data) {
- PVT(l_pos)->events_sign_key = l_sign_cert->enc_key;
- log_it(L_NOTICE, "Loaded \"%s\" certificate to sign PoS events", l_sign_cert_str);
- } else {
- log_it(L_ERROR, "Certificate \"%s\" has no private key", l_sign_cert_str);
- }
- } else {
- log_it(L_ERROR, "No sign certificate provided, can't sign any events");
- }
- return 0;
-}
-
-
-/**
- * @brief s_chain_cs_dag_callback_delete
- * @param a_dag
- */
-static void s_callback_delete(dap_chain_cs_dag_t * a_dag)
-{
- dap_chain_cs_dag_pos_t * l_pos = DAP_CHAIN_CS_DAG_POS ( a_dag );
-
- if ( l_pos->_pvt ) {
- dap_chain_cs_dag_pos_pvt_t * l_pos_pvt = PVT ( l_pos );
- DAP_DELETE ( l_pos_pvt);
- }
-
- if ( l_pos->_inheritor ) {
- DAP_DELETE ( l_pos->_inheritor );
- }
-}
-
-/**
- * @brief
- * create event
- * @param a_dag
- * @param a_datum
- * @param a_hashes
- * @param a_hashes_count
- * @param a_dag_event_size
- * @return dap_chain_cs_dag_event_t*
- */
-static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a_dag, dap_chain_datum_t * a_datum,
- dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count,
- size_t *a_dag_event_size)
-{
- dap_return_val_if_fail(a_dag && a_dag->chain && DAP_CHAIN_CS_DAG_POS(a_dag) && a_datum, NULL);
- dap_chain_cs_dag_pos_t * l_pos = DAP_CHAIN_CS_DAG_POS(a_dag);
-
- if( PVT(l_pos)->events_sign_key == NULL) {
- log_it(L_ERROR, "Can't sign event with events-sign-wallet in [dag-pos] section");
- return NULL;
- }
- if(a_datum || (a_hashes && a_hashes_count)) {
- dap_chain_cs_dag_event_t * l_event = dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_dag->round_current, a_datum,
- PVT(l_pos)->events_sign_key, a_hashes, a_hashes_count, a_dag_event_size);
- return l_event;
- } else
- return NULL;
-}
-
-/**
- * @brief
- * function makes event singing verification
- * @param a_dag dag object
- * @param a_dag_event dap_chain_cs_dag_event_t
- * @param a_dag_event_size size_t size of event object
- * @return int
- */
-static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_event_t * a_dag_event, size_t a_dag_event_size)
-{
- dap_chain_cs_dag_pos_pvt_t * l_pos_pvt = PVT ( DAP_CHAIN_CS_DAG_POS( a_dag ) );
-
- if (sizeof (a_dag_event->header)>= a_dag_event_size){
- log_it(L_WARNING,"Incorrect size with event %p on chain %s", a_dag_event, a_dag->chain->name);
- return -7;
- }
- size_t l_offset_signs = dap_chain_cs_dag_event_calc_size_excl_signs(a_dag_event, a_dag_event_size);
- if ( a_dag_event->header.signs_count >= l_pos_pvt->confirmations_minimum ){
- uint16_t l_verified_num = 0;
-
- for ( size_t l_sig_pos=0; l_sig_pos < a_dag_event->header.signs_count; l_sig_pos++ ){
- dap_sign_t * l_sign = dap_chain_cs_dag_event_get_sign(a_dag_event, a_dag_event_size,l_sig_pos);
- if ( l_sign == NULL){
- log_it(L_WARNING, "Event is NOT signed with anything: sig pos %zu, event size %zu", l_sig_pos, a_dag_event_size);
- return -4;
- }
-
- bool l_sign_size_correct = dap_sign_verify_size(l_sign, a_dag_event_size - l_offset_signs);
- if (!l_sign_size_correct) {
- log_it(L_WARNING, "Event's sign size is incorrect");
- return -41;
- }
- size_t l_signs_total = a_dag_event->header.signs_count;
- a_dag_event->header.signs_count = l_sig_pos; // temporary change for sign verification
- size_t l_dag_event_size_without_sign = dap_chain_cs_dag_event_calc_size_excl_signs(a_dag_event,a_dag_event_size);
- int l_sign_verified = dap_sign_verify(l_sign, a_dag_event, l_dag_event_size_without_sign);
- a_dag_event->header.signs_count = l_signs_total;
- if (l_sign_verified) {
- log_it(L_WARNING, "Event's sign is incorrect: code %d", l_sign_verified);
- return -41;
- }
-
- }
- // Check number
- if ( l_verified_num >= l_pos_pvt->confirmations_minimum ){
- // Passed all checks
- return 0;
- }else{
- log_it(L_WARNING, "Wrong event: only %hu/%hu signs are valid", l_verified_num, l_pos_pvt->confirmations_minimum );
- return -2;
- }
- }else{
- log_it(L_WARNING,"Wrong signature number with event %p on chain %s", a_dag_event, a_dag->chain->name);
- return -2; // Wrong signatures number
- }
-}
diff --git a/modules/consensus/dag-pos/include/dap_chain_cs_dag_pos.h b/modules/consensus/dag-pos/include/dap_chain_cs_dag_pos.h
deleted file mode 100644
index db58e43bdad1ddae42d9b6c02402bea87729f4ea..0000000000000000000000000000000000000000
--- a/modules/consensus/dag-pos/include/dap_chain_cs_dag_pos.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Authors:
- * Dmitriy A. Gearasimov <gerasimov.dmitriy@demlabs.net>
- * DeM Labs Inc. https://demlabs.net
- * Kelvin Project https://github.com/kelvinblockchain
- * Copyright (c) 2017-2018
- * All rights reserved.
-
- This file is part of DAP (Distributed Applications Platform) the open source project
-
- DAP (Distributed Applications Platform) is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- DAP is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
-*/
-#pragma once
-#include "dap_chain_cs_dag.h"
-#include "dap_cert.h"
-
-typedef struct dap_chain_cs_dag_pos
-{
- dap_chain_t * chain;
- dap_chain_cs_dag_t * dag;
- void * _pvt;
- void * _inheritor;
-} dap_chain_cs_dag_pos_t;
-
-#define DAP_CHAIN_CS_DAG_POS(a) ( (dap_chain_cs_dag_pos_t *) (a)->_inheritor)
-
-
-int dap_chain_cs_dag_pos_init();
-void dap_chain_cs_dag_pos_deinit(void);
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 02d71f511d83e8fde1a5c5f151ed41d20f2bf93d..0ce700904af8229199d96890c481b74bc9d344d8 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -456,19 +456,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG(a_chain);
dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *) a_atom;
- dap_chain_cs_dag_event_item_t * l_event_item = DAP_NEW_Z(dap_chain_cs_dag_event_item_t);
- if (!l_event_item) {
- log_it(L_CRITICAL, "Memory allocation error");
- return ATOM_REJECT;
- }
- pthread_mutex_t *l_events_mutex = &PVT(l_dag)->events_mutex;
- l_event_item->event = l_event;
- l_event_item->event_size = a_atom_size;
- l_event_item->ts_added = dap_time_now();
-
dap_chain_hash_fast_t l_event_hash = *a_atom_hash;
- l_event_item->hash = l_event_hash;
-
if(s_debug_more) {
char l_event_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE] = { '\0' };
dap_chain_hash_fast_to_str(&l_event_hash, l_event_hash_str, sizeof(l_event_hash_str));
@@ -496,8 +484,8 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
default:
break;
}
-
- if ( !(l_event_item = DAP_NEW_Z(dap_chain_cs_dag_event_item_t)) ) {
+ dap_chain_cs_dag_event_item_t *l_event_item = DAP_NEW_Z(dap_chain_cs_dag_event_item_t);
+ if ( !l_event_item ) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
pthread_mutex_unlock(&PVT(l_dag)->events_mutex);
return ATOM_REJECT;
@@ -751,48 +739,28 @@ dap_chain_cs_dag_event_t* dap_chain_cs_dag_find_event_by_hash(dap_chain_cs_dag_t
return l_event;
}
-static bool s_event_verify_size(dap_chain_cs_dag_event_t *a_event, size_t a_event_size)
-{
- if (sizeof(a_event->header) >= a_event_size) {
- log_it(L_WARNING, "Size of atom is %zd that is equal or less then header %zd", a_event_size, sizeof(a_event->header));
- return false;
- }
- size_t l_sign_offset = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, a_event_size);
- if (l_sign_offset >= a_event_size)
- return false;
- if (a_event->header.signs_count > UINT8_MAX)
- return false;
- uint8_t i;
- for (i = 0; i < a_event->header.signs_count && l_sign_offset < a_event_size; ++i) {
- dap_sign_t *l_sign = (dap_sign_t*)((uint8_t*)a_event + l_sign_offset);
- l_sign_offset += dap_sign_get_size(l_sign);
- }
- if (i != a_event->header.signs_count) {
- log_it(L_WARNING, "Malformed event! Only %d of claimed %d signs fit data size%s",
- i, a_event->header.signs_count, l_sign_offset == a_event_size ? "" : ", incomplete sequence");
-
- }
- return l_sign_offset == a_event_size;
-}
-
/**
* @brief s_chain_callback_atom_verify Verify atomic element
* @param a_chain
* @param a_atom
* @return
*/
-static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_chain, dap_chain_atom_ptr_t a_atom,size_t a_atom_size, dap_chain_hash_fast_t *a_atom_hash)
+static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t *a_chain, dap_chain_atom_ptr_t a_atom, size_t a_atom_size, dap_chain_hash_fast_t *a_atom_hash)
{
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG(a_chain);
dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *) a_atom;
dap_chain_atom_verify_res_t res = ATOM_ACCEPT;
pthread_mutex_t *l_events_mutex = &PVT(l_dag)->events_mutex;
+ if (a_atom_size < sizeof(dap_chain_cs_dag_event_t)) {
+ log_it(L_WARNING, "Too small event size %zu, less than event header", a_atom_size);
+ return ATOM_REJECT;
+ }
if (l_event->header.version) {
- debug_if(s_debug_more, L_WARNING, "Unsupported event version, possible corrupted event");
+ log_it(L_WARNING, "Unsupported event version, possible corrupted event");
return ATOM_REJECT;
}
if (l_event->header.chain_id.uint64 != a_chain->id.uint64) {
- debug_if(s_debug_more, L_WARNING, "Event from another chain, possible corrupted event");
+ log_it(L_WARNING, "Event from another chain, possible corrupted event");
return ATOM_REJECT;
}
dap_chain_hash_fast_t l_event_hash = *a_atom_hash;
@@ -806,8 +774,8 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_
return ATOM_ACCEPT;
}
}
- if (!s_event_verify_size(l_event, a_atom_size)) {
- debug_if(s_debug_more, L_WARNING,"Event size not equal to expected");
+ if (dap_chain_cs_dag_event_calc_size(l_event, a_atom_size) != a_atom_size) {
+ debug_if(s_debug_more, L_WARNING, "Event size not equal to expected");
return ATOM_REJECT;
}
@@ -860,9 +828,8 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_
}
//consensus
- if(res == ATOM_ACCEPT)
- if(l_dag->callback_cs_verify ( l_dag, l_event,a_atom_size ))
- res = ATOM_REJECT;
+ if (res == ATOM_ACCEPT && l_dag->callback_cs_verify(l_dag, l_event, a_atom_hash))
+ res = ATOM_REJECT;
return res;
}
@@ -1417,7 +1384,7 @@ 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
+ if ( ( l_ret_event_verify = l_dag->callback_cs_verify(l_dag, l_event, &l_event_hash) ) !=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 = -DAP_CHAIN_NODE_CLI_COM_DAG_EVENT_ERR;
diff --git a/modules/type/dag/dap_chain_cs_dag_event.c b/modules/type/dag/dap_chain_cs_dag_event.c
index 8dd90470ede55e569c2113830e3023581073de8a..4402212cd531c7699be33a6d75aac0e7a1e28adc 100644
--- a/modules/type/dag/dap_chain_cs_dag_event.c
+++ b/modules/type/dag/dap_chain_cs_dag_event.c
@@ -95,6 +95,49 @@ dap_chain_cs_dag_event_t *dap_chain_cs_dag_event_new(dap_chain_id_t a_chain_id,
return l_event_new;
}
+/**
+ * @brief dap_chain_cs_dag_event_calc_size_excl_signs
+ * @param a_event
+ * @return
+ */
+size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size)
+{
+ dap_return_val_if_fail(a_event, 0);
+ if (a_limit_size && a_limit_size < sizeof(a_event->header))
+ return 0;
+ size_t l_hashes_size = a_event->header.hash_count * sizeof(dap_chain_hash_fast_t);
+ if (a_limit_size && a_limit_size < l_hashes_size + sizeof(a_event->header) + sizeof(dap_chain_datum_t))
+ return 0;
+ dap_chain_datum_t *l_datum = (dap_chain_datum_t*) (a_event->hashes_n_datum_n_signs + l_hashes_size);
+ size_t l_ret = dap_chain_datum_size(l_datum) + l_hashes_size + sizeof(a_event->header);
+ if (a_limit_size && a_limit_size < l_ret)
+ return 0;
+ return l_ret;
+}
+
+/**
+ * @brief dap_chain_cs_dag_event_calc_size
+ * @param a_event
+ * @return
+ */
+size_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size)
+{
+ dap_return_val_if_fail(a_event, 0);
+ size_t l_signs_offset = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, a_limit_size);
+ if (!l_signs_offset)
+ return 0;
+ byte_t *l_signs = (byte_t *)a_event + l_signs_offset;
+ size_t l_signs_size = 0;
+ for (uint16_t l_signs_passed = 0; l_signs_passed < a_event->header.signs_count; l_signs_passed++) {
+ dap_sign_t *l_sign = (dap_sign_t *)(l_signs + l_signs_size);
+ if (a_limit_size && a_limit_size < l_signs_offset + l_signs_size + sizeof(dap_sign_t))
+ return 0;
+ l_signs_size += dap_sign_get_size(l_sign);
+ }
+ size_t l_total_size = l_signs_offset + l_signs_size;
+ return a_limit_size && l_total_size > a_limit_size ? 0 : l_total_size;
+}
+
/**
* @brief dap_chain_cs_dag_event_sign_add
* @param a_event
diff --git a/modules/type/dag/include/dap_chain_cs_dag.h b/modules/type/dag/include/dap_chain_cs_dag.h
index 0043a3afbe2f1c151a2c3e558275ff9f0687403b..1020634067194f1684b3fb16e7197d3690456880 100644
--- a/modules/type/dag/include/dap_chain_cs_dag.h
+++ b/modules/type/dag/include/dap_chain_cs_dag.h
@@ -31,9 +31,9 @@
typedef struct dap_chain_cs_dag dap_chain_cs_dag_t;
-typedef void (*dap_chain_cs_dag_callback_t)(dap_chain_cs_dag_t *);
+typedef void (*dap_chain_cs_dag_callback_t)(dap_chain_cs_dag_t *a_dag);
typedef void (*dap_chain_cs_dag_callback_rc_ptr_t)(dap_chain_cs_dag_t *, int a_rc, void * a_arg);
-typedef int (*dap_chain_cs_dag_callback_event_t)(dap_chain_cs_dag_t *, dap_chain_cs_dag_event_t *,size_t);
+typedef int (*dap_chain_cs_dag_callback_event_t)(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_event, dap_hash_fast_t *a_event_hash);
typedef dap_chain_cs_dag_event_t * (*dap_chain_cs_dag_callback_event_create_t)(dap_chain_cs_dag_t *,
dap_chain_datum_t *,
diff --git a/modules/type/dag/include/dap_chain_cs_dag_event.h b/modules/type/dag/include/dap_chain_cs_dag_event.h
index 0a5513912997e5a97ffa2bcb1512eafc2402df95..5f4d6a1c94255515bb77d0487764860e1457c3cb 100644
--- a/modules/type/dag/include/dap_chain_cs_dag_event.h
+++ b/modules/type/dag/include/dap_chain_cs_dag_event.h
@@ -90,47 +90,9 @@ bool dap_chain_cs_dag_event_sign_exists(dap_chain_cs_dag_event_t *a_event, size_
bool dap_chain_cs_dag_event_round_sign_exists(dap_chain_cs_dag_event_round_item_t *a_round_item, dap_enc_key_t * a_key);
dap_sign_t * dap_chain_cs_dag_event_get_sign( dap_chain_cs_dag_event_t * a_event, size_t a_event_size, uint16_t a_sign_number);
-/**
- * @brief dap_chain_cs_dag_event_calc_size_excl_signs
- * @param a_event
- * @return
- */
-static inline size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, size_t a_event_size)
-{
- if (a_event_size < sizeof(a_event->header))
- return 0;
- size_t l_hashes_size = a_event->header.hash_count*sizeof(dap_chain_hash_fast_t);
- if (a_event_size < l_hashes_size + sizeof(a_event->header))
- return 0;
- dap_chain_datum_t *l_datum = (dap_chain_datum_t*) (a_event->hashes_n_datum_n_signs + l_hashes_size);
- size_t l_ret = dap_chain_datum_size(l_datum) + l_hashes_size + sizeof(a_event->header);
- if (a_event_size < l_ret)
- return 0;
- return l_ret;
-}
+size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size);
+size_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size);
-/**
- * @brief dap_chain_cs_dag_event_calc_size
- * @param a_event
- * @return
- */
-static inline size_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size)
-{
- if (!a_event || !a_limit_size)
- return 0;
- size_t l_signs_offset = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, a_limit_size);
- if (!l_signs_offset)
- return 0;
- byte_t *l_signs = (byte_t *)a_event + l_signs_offset;
- size_t l_signs_size = 0;
- for (uint16_t l_signs_passed = 0; l_signs_passed < a_event->header.signs_count; l_signs_passed++) {
- dap_sign_t *l_sign = (dap_sign_t *)(l_signs + l_signs_size);
- l_signs_size += dap_sign_get_size(l_sign);
- if (a_limit_size < l_signs_offset + l_signs_size)
- return 0;
- }
- return l_signs_offset + l_signs_size;
-}
/**
* @brief dap_chain_cs_dag_event_calc_hash