Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • cellframe/cellframe-sdk
  • MIKA83/cellframe-sdk
2 results
Show changes
Commits on Source (151)
51 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 528 additions and 760 deletions
dap-sdk @ ea267c0f
Compare f2b762fc...ea267c0f
Subproject commit f2b762fcfbf3d799029d9a52963b09fefd9e711b
Subproject commit ea267c0f9432a1fb94d70a4d400c265c63405ef8
modules/chain/dap_chain_cell.c
View file @ 63c82b97
......@@ -107,6 +107,17 @@ int dap_chain_cell_init(void)
return 0;
}
#ifndef DAP_OS_WINDOWS
DAP_STATIC_INLINE void s_cell_reclaim_cur_volume(dap_chain_cell_t *a_cell) {
if (
#ifdef MADV_PAGEOUT
//madvise(a_cell->map, (size_t)(a_cell->map_end - a_cell->map), MADV_PAGEOUT) &&
#endif
madvise(a_cell->map, (size_t)(a_cell->map_end - a_cell->map), MADV_DONTNEED) )
log_it(L_ERROR, "Unable to reclaim the previous volume, errno %d: \"%s\"", errno, dap_strerror(errno));
}
#endif
DAP_STATIC_INLINE int s_cell_file_write_header(dap_chain_cell_t *a_cell)
{
dap_chain_cell_file_header_t l_hdr = {
......@@ -120,7 +131,7 @@ DAP_STATIC_INLINE int s_cell_file_write_header(dap_chain_cell_t *a_cell)
return fwrite(&l_hdr, sizeof(l_hdr), 1, a_cell->file_storage) ? fflush(a_cell->file_storage) : -1;
}
DAP_STATIC_INLINE int s_cell_map_new_volume(dap_chain_cell_t *a_cell, size_t a_fpos) {
DAP_STATIC_INLINE int s_cell_map_new_volume(dap_chain_cell_t *a_cell, size_t a_fpos, bool a_load) {
int l_fildes = fileno(a_cell->file_storage);
#ifdef DAP_OS_WINDOWS
HANDLE hSection = NULL;
......@@ -135,12 +146,9 @@ DAP_STATIC_INLINE int s_cell_map_new_volume(dap_chain_cell_t *a_cell, size_t a_f
};
NTSTATUS err = pfnNtCreateSection(&hSection, SECTION_MAP_READ|SECTION_EXTEND_SIZE|SECTION_MAP_WRITE,
NULL, &SectionSize, PAGE_READWRITE, SEC_RESERVE,
(HANDLE)_get_osfhandle(l_fildes));
if ( !NT_SUCCESS(err) ) {
log_it(L_ERROR, "NtCreateSection() failed, status %lx", err);
return -1;
}
NULL, &SectionSize, PAGE_READWRITE, SEC_RESERVE, (HANDLE)_get_osfhandle(l_fildes));
if ( !NT_SUCCESS(err) )
return log_it(L_ERROR, "NtCreateSection() failed, status %lx", err), -1;
a_cell->map_range_bounds = dap_list_append(a_cell->map_range_bounds, hSection);
}
#endif
......@@ -158,23 +166,17 @@ DAP_STATIC_INLINE int s_cell_map_new_volume(dap_chain_cell_t *a_cell, size_t a_f
LARGE_INTEGER Offset = {
.QuadPart = l_volume_start
};
if ( !NT_SUCCESS ( err = pfnNtMapViewOfSection(hSection, GetCurrentProcess(),
(HANDLE)&a_cell->map, 0, 0,
&Offset, &l_map_size,
ViewUnmap, MEM_RESERVE,
PAGE_WRITECOPY) ) )
{
log_it(L_ERROR, "NtMapViewOfSection() failed, status %lx", err);
NtClose(hSection);
return -1;
}
err = pfnNtMapViewOfSection(hSection, GetCurrentProcess(), (HANDLE)&a_cell->map, 0, 0,
&Offset, &l_map_size, ViewUnmap, MEM_RESERVE, PAGE_WRITECOPY);
if ( !NT_SUCCESS(err) )
return NtClose(hSection), log_it(L_ERROR, "NtMapViewOfSection() failed, status %lx", err), -1;
#else
if ( MAP_FAILED == (a_cell->map = mmap(NULL, l_map_size, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fileno(a_cell->file_storage), l_volume_start)) ) {
log_it(L_ERROR, "Chain cell \"%s\" 0x%016"DAP_UINT64_FORMAT_X" cannot be mapped, errno %d",
a_cell->file_storage_path, a_cell->id.uint64, errno);
return -1;
}
if (a_load)
s_cell_reclaim_cur_volume(a_cell);
if (( a_cell->map = mmap(NULL, l_map_size, PROT_READ|PROT_WRITE, MAP_PRIVATE,
fileno(a_cell->file_storage), l_volume_start) ) == MAP_FAILED )
return log_it(L_ERROR, "Chain cell \"%s\" 0x%016"DAP_UINT64_FORMAT_X" cannot be mapped, errno %d",
a_cell->file_storage_path, a_cell->id.uint64, errno), -1;
#ifdef DAP_OS_DARWIN
a_cell->cur_vol_start = l_volume_start;
#endif
......@@ -182,6 +184,10 @@ DAP_STATIC_INLINE int s_cell_map_new_volume(dap_chain_cell_t *a_cell, size_t a_f
a_cell->map_pos = a_cell->map + l_offset;
a_cell->map_range_bounds = dap_list_append(a_cell->map_range_bounds, a_cell->map);
a_cell->map_range_bounds = dap_list_append(a_cell->map_range_bounds, a_cell->map_end = a_cell->map + l_map_size);
#ifndef DAP_OS_WINDOWS
if (a_load)
madvise(a_cell->map, l_map_size, MADV_SEQUENTIAL);
#endif
return 0;
}
......@@ -259,7 +265,7 @@ dap_chain_cell_t * dap_chain_cell_create_fill(dap_chain_t * a_chain, dap_chain_c
fflush(l_file);
}
if ( a_chain->is_mapped && s_cell_map_new_volume(l_cell, 0) ) {
if ( a_chain->is_mapped && s_cell_map_new_volume(l_cell, 0, true) ) {
CLEANUP_AND_RET;
}
#undef CLEANUP_AND_RET
......@@ -454,7 +460,7 @@ int dap_chain_cell_load(dap_chain_t *a_chain, dap_chain_cell_t *a_cell)
for ( l_el_size = 0; l_pos < l_full_size; ++q, l_pos += l_el_size + sizeof(uint64_t) ) {
l_vol_rest = (uint64_t)( a_cell->map_end - a_cell->map_pos );
if ( l_vol_rest <= sizeof(uint64_t) || l_vol_rest - sizeof(uint64_t) <= *(uint64_t*)a_cell->map_pos)
if ( s_cell_map_new_volume(a_cell, l_pos) )
if ( s_cell_map_new_volume(a_cell, l_pos, true) )
break;
if (*(uint64_t*)a_cell->map_pos > l_full_size - l_pos ) {
log_it(L_ERROR, "Atom size exeeds file remainder: %zu > %zu. "
......@@ -469,6 +475,9 @@ int dap_chain_cell_load(dap_chain_t *a_chain, dap_chain_cell_t *a_cell)
a_cell->map_pos += l_el_size;
a_chain->load_progress = (int)((float)l_pos/l_full_size * 100 + 0.5);
}
#ifndef DAP_OS_WINDOWS
s_cell_reclaim_cur_volume(a_cell);
#endif
} else {
DAP_DELETE(l_hdr);
size_t l_read = 0;
......@@ -485,7 +494,7 @@ int dap_chain_cell_load(dap_chain_t *a_chain, dap_chain_cell_t *a_cell)
break;
}
l_pos += sizeof(uint64_t) + ( l_read = fread((void*)l_element, 1, l_el_size, a_cell->file_storage) );
a_chain->load_progress = (int)((double)l_pos/l_full_size * 100 + 0.5);
a_chain->load_progress = (int)((float)l_pos/l_full_size * 100 + 0.5);
if (l_read != l_el_size) {
log_it(L_ERROR, "Read only %lu of %zu bytes, stop cell loading", l_read, l_el_size);
DAP_DELETE(l_element);
......@@ -519,7 +528,7 @@ static int s_cell_file_atom_add(dap_chain_cell_t *a_cell, dap_chain_atom_ptr_t a
debug_if (s_debug_more, L_DEBUG, "Before filling volume for atom size %ld, stream pos of %s is %lu, map pos is %lu, space left in map %lu",
a_atom_size, a_cell->file_storage_path, l_pos, (size_t)(a_cell->map_pos - a_cell->map), (size_t)(a_cell->map_end - a_cell->map_pos));
if ( a_atom_size + sizeof(uint64_t) > (size_t)(a_cell->map_end - a_cell->map_pos) )
if ( s_cell_map_new_volume(a_cell, (size_t)l_pos) )
if ( s_cell_map_new_volume(a_cell, (size_t)l_pos, false) )
return -2;
}
......
modules/chain/dap_chain_ch.c
View file @ 63c82b97
......@@ -154,39 +154,21 @@ static dap_memstat_rec_t s_memstat [MEMSTAT$K_NR] = {
#endif
static const char *s_error_type_to_string(dap_chain_ch_error_type_t a_error)
{
switch (a_error) {
case DAP_CHAIN_CH_ERROR_SYNC_REQUEST_ALREADY_IN_PROCESS:
return "SYNC_REQUEST_ALREADY_IN_PROCESS";
case DAP_CHAIN_CH_ERROR_INCORRECT_SYNC_SEQUENCE:
return "INCORRECT_SYNC_SEQUENCE";
case DAP_CHAIN_CH_ERROR_SYNC_TIMEOUT:
return "SYNCHRONIZATION TIMEOUT";
case DAP_CHAIN_CH_ERROR_CHAIN_PKT_DATA_SIZE:
return "INVALID_PACKET_SIZE";
case DAP_CHAIN_CH_ERROR_LEGACY_PKT_DATA_SIZE:
return "INVALID_LEGACY_PACKET_SIZE";
case DAP_CHAIN_CH_ERROR_NET_INVALID_ID:
return "INVALID_NET_ID";
case DAP_CHAIN_CH_ERROR_CHAIN_NOT_FOUND:
return "CHAIN_NOT_FOUND";
case DAP_CHAIN_CH_ERROR_ATOM_NOT_FOUND:
return "ATOM_NOT_FOUND";
case DAP_CHAIN_CH_ERROR_UNKNOWN_CHAIN_PKT_TYPE:
return "UNKNOWN_CHAIN_PACKET_TYPE";
case DAP_CHAIN_CH_ERROR_GLOBAL_DB_INTERNAL_NOT_SAVED:
return "GLOBAL_DB_INTERNAL_SAVING_ERROR";
case DAP_CHAIN_CH_ERROR_NET_IS_OFFLINE:
return "NET_IS_OFFLINE";
case DAP_CHAIN_CH_ERROR_OUT_OF_MEMORY:
return "OUT_OF_MEMORY";
case DAP_CHAIN_CH_ERROR_INTERNAL:
return "INTERNAL_ERROR";
default:
return "UNKNOWN_ERROR";
}
}
const char* const s_error_type_to_string[] = {
[DAP_CHAIN_CH_ERROR_SYNC_REQUEST_ALREADY_IN_PROCESS]= "SYNC_REQUEST_ALREADY_IN_PROCESS",
[DAP_CHAIN_CH_ERROR_INCORRECT_SYNC_SEQUENCE] = "INCORRECT_SYNC_SEQUENCE",
[DAP_CHAIN_CH_ERROR_SYNC_TIMEOUT] = "SYNCHRONIZATION TIMEOUT",
[DAP_CHAIN_CH_ERROR_CHAIN_PKT_DATA_SIZE] = "INVALID_PACKET_SIZE",
[DAP_CHAIN_CH_ERROR_LEGACY_PKT_DATA_SIZE] = "INVALID_LEGACY_PACKET_SIZE",
[DAP_CHAIN_CH_ERROR_NET_INVALID_ID] = "INVALID_NET_ID",
[DAP_CHAIN_CH_ERROR_CHAIN_NOT_FOUND] = "CHAIN_NOT_FOUND",
[DAP_CHAIN_CH_ERROR_ATOM_NOT_FOUND] = "ATOM_NOT_FOUND",
[DAP_CHAIN_CH_ERROR_UNKNOWN_CHAIN_PKT_TYPE] = "UNKNOWN_CHAIN_PACKET_TYPE",
[DAP_CHAIN_CH_ERROR_GLOBAL_DB_INTERNAL_NOT_SAVED] = "GLOBAL_DB_INTERNAL_SAVING_ERROR",
[DAP_CHAIN_CH_ERROR_NET_IS_OFFLINE] = "NET_IS_OFFLINE",
[DAP_CHAIN_CH_ERROR_OUT_OF_MEMORY] = "OUT_OF_MEMORY",
[DAP_CHAIN_CH_ERROR_INTERNAL] = "INTERNAL_ERROR"
};
/**
* @brief dap_chain_ch_init
......@@ -618,11 +600,9 @@ static bool s_sync_in_chains_callback(void *a_arg)
DAP_DELETE(l_args);
return false;
}
char *l_atom_hash_str = NULL;
dap_hash_fast_t l_atom_hash = { };
dap_hash_fast(l_atom, l_atom_size, &l_atom_hash);
if (s_debug_more)
l_atom_hash_str = dap_hash_fast_to_str_static(&l_atom_hash);
dap_hash_fast(l_atom, l_atom_size, &l_atom_hash);
char *l_atom_hash_str = dap_hash_fast_to_str_static(&l_atom_hash);
dap_chain_atom_verify_res_t l_atom_add_res = l_chain->callback_atom_add(l_chain, l_atom, l_atom_size, &l_atom_hash, false);
bool l_ack_send = false;
switch (l_atom_add_res) {
......@@ -688,7 +668,7 @@ void dap_stream_ch_write_error_unsafe(dap_stream_ch_t *a_ch, dap_chain_net_id_t
{
dap_chain_ch_t *l_ch_chain = DAP_CHAIN_CH(a_ch);
dap_return_if_fail(l_ch_chain);
const char *l_err_str = s_error_type_to_string(a_error);
const char *l_err_str = a_error < DAP_CHAIN_CH_ERROR_LAST ? s_error_type_to_string[a_error] : "UNDEFINED ERROR";
dap_chain_ch_pkt_write_unsafe(a_ch, DAP_CHAIN_CH_PKT_TYPE_ERROR, a_net_id, a_chain_id, a_cell_id, l_err_str, strlen(l_err_str) + 1, DAP_CHAIN_CH_PKT_VERSION_LEGACY);
s_ch_chain_go_idle(l_ch_chain);
}
......@@ -1544,7 +1524,7 @@ static bool s_sync_timer_callback(void *a_arg)
}
bool l_timer_break = false;
const char *l_err_str = s_error_type_to_string(DAP_CHAIN_CH_ERROR_SYNC_TIMEOUT);
const char* l_err_str = s_error_type_to_string[DAP_CHAIN_CH_ERROR_SYNC_TIMEOUT];
if (l_ch_chain->sync_context) {
struct sync_context *l_context = l_ch_chain->sync_context;
if (l_context->last_activity + s_sync_timeout <= dap_time_now()) {
......
modules/chain/dap_chain_cs.c
View file @ 63c82b97
......@@ -134,10 +134,11 @@ int dap_chain_cs_create(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
HASH_FIND_STR(s_cs_callbacks, l_consensus, l_item );
if (l_item) {
log_it(L_NOTICE,"Consensus \"%s\" found, prepare to parse config file",l_item->name );
int res = 0;
if (l_item->callback_init)
l_item->callback_init(a_chain, a_chain_cfg);
res = l_item->callback_init(a_chain, a_chain_cfg);
DAP_CHAIN_PVT(a_chain)->cs_name = l_item->name;
return 0;
return res;
} else {
log_it(L_ERROR,"Can't find consensus \"%s\"",dap_config_get_item_str( a_chain_cfg, "chain", "consensus"));
return -1;
......
modules/chain/include/dap_chain.h
View file @ 63c82b97
......@@ -62,7 +62,10 @@ typedef struct dap_chain_datum_iter {
size_t cur_size;
dap_chain_hash_fast_t *cur_hash;
dap_chain_hash_fast_t *cur_atom_hash;
uint32_t action;
dap_chain_net_srv_uid_t uid;
int ret_code;
char *token_ticker;
void *cur_item;
} dap_chain_datum_iter_t;
......
modules/chain/include/dap_chain_ch.h
View file @ 63c82b97
......@@ -63,7 +63,9 @@ typedef enum dap_chain_ch_error_type {
DAP_CHAIN_CH_ERROR_INTERNAL,
// Legacy
DAP_CHAIN_CH_ERROR_GLOBAL_DB_INTERNAL_NOT_SAVED,
DAP_CHAIN_CH_ERROR_LEGACY_PKT_DATA_SIZE
DAP_CHAIN_CH_ERROR_LEGACY_PKT_DATA_SIZE,
//
DAP_CHAIN_CH_ERROR_LAST
} dap_chain_ch_error_type_t;
int dap_chain_ch_init(void);
......
modules/chain/tests/dap_chain_ledger_tests.c
View file @ 63c82b97
......@@ -491,7 +491,7 @@ int dap_ledger_test_add_new_datum (uint16_t a_datum_type, void* a_datum, size_t
{
dap_chain_datum_t* l_new_datum = dap_chain_datum_create(a_datum_type, a_datum, a_datum_size);
size_t l_new_datum_size = a_datum_size + sizeof(l_new_datum->header);
int status = dap_chain_datum_add(a_chain, l_new_datum, l_new_datum_size, a_datum_hash);
int status = dap_chain_datum_add(a_chain, l_new_datum, l_new_datum_size, a_datum_hash, NULL);
dap_assert(status == 0, "Test of transaction adding to ledger:");
return status;
}
......@@ -531,7 +531,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_assert(l_second_tx, "Test of creating second tx:");
dap_chain_hash_fast_t l_second_tx_hash = {0};
dap_hash_fast(l_second_tx, dap_chain_datum_tx_get_size(l_second_tx), &l_second_tx_hash);
dap_assert(!dap_ledger_tx_add(a_ledger, l_second_tx, &l_second_tx_hash, false), "Test of second transaction adding to ledger:");
dap_assert(!dap_ledger_tx_add(a_ledger, l_second_tx, &l_second_tx_hash, false, NULL), "Test of second transaction adding to ledger:");
dap_ledger_test_print_balance(a_ledger, &l_addr);
// try to remove spent tx
......@@ -548,7 +548,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_assert_PIF(l_cond_tx, "Test of creating conditional transaction:");
dap_chain_hash_fast_t l_cond_tx_hash = {0};
dap_hash_fast(l_cond_tx, dap_chain_datum_tx_get_size(l_first_tx), &l_cond_tx_hash);
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false), "Test of conditional transaction adding to ledger:");
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false, NULL), "Test of conditional transaction adding to ledger:");
dap_ledger_test_print_balance(a_ledger, &l_addr);
dap_assert(!dap_ledger_tx_remove(a_ledger, l_cond_tx, &l_cond_tx_hash), "Test of conditional transaction removing from ledger:");
l_balance_after = dap_ledger_test_print_balance(a_ledger, &l_addr);
......@@ -561,7 +561,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_assert_PIF(l_cond_tx, "Test of creating conditional transaction:");
dap_hash_fast_t l_cond_tx_hash = {};
dap_hash_fast(l_cond_tx, dap_chain_datum_tx_get_size(l_cond_tx), &l_cond_tx_hash);
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false), "Test of conditional transaction adding to ledger:");
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false, NULL), "Test of conditional transaction adding to ledger:");
dap_ledger_test_print_balance(a_ledger, &l_addr);
dap_cert_t *l_cond_spender_cert = dap_cert_generate_mem_with_seed("newCert", DAP_ENC_KEY_TYPE_SIG_PICNIC, "FMknbirh8*^#$RYU*q", 18);
......@@ -571,7 +571,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_chain_datum_tx_t *l_cond_spendind_tx = dap_ledger_test_create_spend_tx_cond(a_from_key, &l_cond_tx_hash, l_cond_spender_cert->enc_key, dap_chain_uint256_from(1U),a_ledger);
dap_chain_hash_fast_t l_spend_cond_tx_hash = {0};
dap_hash_fast(l_cond_spendind_tx, dap_chain_datum_tx_get_size(l_cond_spendind_tx), &l_spend_cond_tx_hash);
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_spendind_tx, &l_spend_cond_tx_hash, false), "Test adding of transaction spending to a conditional transaction to ledger:");
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_spendind_tx, &l_spend_cond_tx_hash, false, NULL), "Test adding of transaction spending to a conditional transaction to ledger:");
uint256_t l_cond_spending_balance_after = dap_ledger_test_print_balance(a_ledger, &l_cond_spender_addr);
dap_assert(!compare256(l_cond_spending_balance_after, dap_chain_uint256_from(1U)), "Check balance after spending:");
dap_ledger_test_print_balance(a_ledger, &l_cond_spender_addr);
......@@ -588,7 +588,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_chain_datum_tx_t *l_cond_tx = dap_ledger_test_create_tx_cond(a_from_key, a_prev_hash, &l_addr_first, dap_chain_uint256_from(2U),a_ledger);
dap_hash_fast_t l_cond_tx_hash = {};
dap_hash_fast(l_cond_tx, dap_chain_datum_tx_get_size(l_cond_tx), &l_cond_tx_hash);
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false), "Adding of cond transaction to ledger is");
dap_assert(!dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false, NULL), "Adding of cond transaction to ledger is");
dap_cert_t *l_cond_spending_cert = dap_cert_generate_mem_with_seed("newCert", DAP_ENC_KEY_TYPE_SIG_PICNIC, "FMknbirh8*^#$RYU*q", 18);
dap_chain_addr_t l_cond_spending_addr = {0};
......@@ -597,7 +597,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_chain_datum_tx_t *l_cond_returning_tx = dap_ledger_test_create_return_from_tx_cond(&l_cond_tx_hash, a_from_key ,a_ledger);
dap_chain_hash_fast_t l_cond_returning_tx_hash = {0};
dap_hash_fast(l_cond_returning_tx, dap_chain_datum_tx_get_size(l_cond_returning_tx), &l_cond_returning_tx_hash);
int err_code = dap_ledger_tx_add(a_ledger, l_cond_returning_tx, &l_cond_returning_tx_hash, false);
int err_code = dap_ledger_tx_add(a_ledger, l_cond_returning_tx, &l_cond_returning_tx_hash, false, NULL);
printf("err_code = %s\n", dap_ledger_check_error_str(err_code));
dap_assert(!err_code, "Returning of funds from cond transaction is");
uint256_t l_cond_spending_balance_after = dap_ledger_test_print_balance(a_ledger, &l_cond_spending_addr);
......@@ -617,7 +617,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_chain_datum_tx_t *l_cond_tx = dap_ledger_test_create_stake_tx_cond(a_from_key, a_prev_hash, dap_chain_uint256_from(20U), a_ledger);
dap_hash_fast_t l_cond_tx_hash = {};
dap_hash_fast(l_cond_tx, dap_chain_datum_tx_get_size(l_cond_tx), &l_cond_tx_hash);
int err_code = dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false);
int err_code = dap_ledger_tx_add(a_ledger, l_cond_tx, &l_cond_tx_hash, false, NULL);
printf("err_code = %s\n", dap_ledger_check_error_str(err_code));
dap_assert(!err_code, "Adding of stake cond transaction to ledger is");
......@@ -632,7 +632,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_chain_datum_tx_t *l_stake_cond_tx = dap_ledger_test_create_stake_tx_cond(a_from_key, a_prev_hash, dap_chain_uint256_from(20U), a_ledger);
dap_hash_fast_t l_stake_cond_tx_hash = {};
dap_hash_fast(l_stake_cond_tx, dap_chain_datum_tx_get_size(l_stake_cond_tx), &l_stake_cond_tx_hash);
int err_code = dap_ledger_tx_add(a_ledger, l_stake_cond_tx, &l_stake_cond_tx_hash, false);
int err_code = dap_ledger_tx_add(a_ledger, l_stake_cond_tx, &l_stake_cond_tx_hash, false, NULL);
printf("err_code = %s\n", dap_ledger_check_error_str(err_code));
dap_assert(!err_code, "Adding of stake cond transaction to ledger is");
sleep(3);
......@@ -644,7 +644,7 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
dap_chain_datum_tx_t *l_unstake_cond_tx = dap_ledger_test_create_unstake_tx_cond(a_from_key, &l_stake_cond_tx_hash, dap_chain_uint256_from(20U), a_ledger);
dap_hash_fast_t l_unstake_cond_tx_hash = {};
dap_hash_fast(l_unstake_cond_tx, dap_chain_datum_tx_get_size(l_unstake_cond_tx), &l_unstake_cond_tx_hash);
err_code = dap_ledger_tx_add(a_ledger, l_unstake_cond_tx, &l_unstake_cond_tx_hash, false);
err_code = dap_ledger_tx_add(a_ledger, l_unstake_cond_tx, &l_unstake_cond_tx_hash, false, NULL);
printf("err_code = %s\n", dap_ledger_check_error_str(err_code));
dap_assert(!err_code, "Adding of unstake cond transaction to ledger is");
uint256_t l_balance_delegated_after_unstaking = dap_ledger_test_print_delegate_balance(a_ledger, &l_addr);
......@@ -694,14 +694,14 @@ dap_hash_fast_t dap_ledger_test_double_spending(
dap_assert_PIF(l_first_tx, "Can't creating base transaction.");
dap_chain_hash_fast_t l_first_tx_hash = {0};
dap_hash_fast(l_first_tx, dap_chain_datum_tx_get_size(l_first_tx), &l_first_tx_hash);
dap_assert_PIF(!dap_ledger_tx_add(a_ledger, l_first_tx, &l_first_tx_hash, false), "Can't add first transaction on ledger");
dap_assert_PIF(!dap_ledger_tx_add(a_ledger, l_first_tx, &l_first_tx_hash, false, NULL), "Can't add first transaction on ledger");
//uint256_t l_balance = dap_ledger_calc_balance(a_ledger, &l_addr_first, s_token_ticker);
// Second tx
dap_chain_datum_tx_t *l_second_tx = dap_ledger_test_create_tx(a_from_key, a_prev_hash,
&a_addr_to, dap_chain_uint256_from(s_standard_value_tx - s_fee));
dap_chain_hash_fast_t l_second_tx_hash = {0};
dap_hash_fast(l_second_tx, dap_chain_datum_tx_get_size(l_second_tx), &l_second_tx_hash);
dap_assert_PIF(dap_ledger_tx_add(a_ledger, l_second_tx, &l_second_tx_hash, false), "Added second transaction on ledger");
dap_assert_PIF(dap_ledger_tx_add(a_ledger, l_second_tx, &l_second_tx_hash, false, NULL), "Added second transaction on ledger");
dap_pass_msg("The verification test is not able to make two normal transactions per one basic transaction.");
return l_first_tx_hash;
}
......@@ -831,7 +831,7 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
*l_addr_1->addr, a_cert);
dap_hash_fast_t l_btx_addr1_hash = {0};
dap_hash_fast(l_btx_addr1, dap_chain_datum_tx_get_size(l_btx_addr1), &l_btx_addr1_hash);
int l_ledger_add_code = dap_ledger_tx_add(a_ledger, l_btx_addr1, &l_btx_addr1_hash, false);
int l_ledger_add_code = dap_ledger_tx_add(a_ledger, l_btx_addr1, &l_btx_addr1_hash, false, NULL);
char *l_ledger_tx_add_str = dap_strdup_printf("Can't add base tx in white address. Code: %d", l_ledger_add_code);
dap_assert_PIF(!l_ledger_add_code, l_ledger_tx_add_str);
DAP_DELETE(l_ledger_tx_add_str);
......@@ -839,13 +839,13 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
dap_chain_datum_tx_t *l_tx_to_addr4 = dap_ledger_test_create_tx(l_addr_1->enc_key, &l_btx_addr1_hash,
l_addr_4->addr, dap_chain_uint256_from(s_total_supply-s_fee));
dap_hash_fast(l_tx_to_addr4, dap_chain_datum_tx_get_size(l_tx_to_addr4), &l_tx_addr4_hash);
dap_assert_PIF(!dap_ledger_tx_add(a_ledger, l_tx_to_addr4, &l_tx_addr4_hash, false),
dap_assert_PIF(!dap_ledger_tx_add(a_ledger, l_tx_to_addr4, &l_tx_addr4_hash, false, NULL),
"Can't add transaction to address from white list in ledger");
dap_chain_datum_tx_t *l_tx_to_addr3 = dap_ledger_test_create_tx(l_addr_4->enc_key, &l_tx_addr4_hash,
l_addr_3->addr, dap_chain_uint256_from(s_total_supply-s_fee));
dap_hash_fast_t l_tx_addr3_hash = {0};
dap_hash_fast(l_tx_to_addr3, dap_chain_datum_tx_get_size(l_tx_to_addr3), &l_tx_addr3_hash);
int res_add_tx = dap_ledger_tx_add(a_ledger, l_tx_to_addr3, &l_tx_addr3_hash, false);
int res_add_tx = dap_ledger_tx_add(a_ledger, l_tx_to_addr3, &l_tx_addr3_hash, false, NULL);
if (!res_add_tx) {
dap_fail("It was possible to carry out a transaction to a forbidden address");
} else {
......@@ -945,20 +945,20 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
*l_addr_2->addr, a_cert);
dap_hash_fast_t l_btx_addr2_hash = {0};
dap_hash_fast(l_btx_addr2, dap_chain_datum_tx_get_size(l_btx_addr2), &l_btx_addr2_hash);
dap_assert_PIF(!dap_ledger_tx_add(a_ledger, l_btx_addr2, &l_btx_addr2_hash, false),
dap_assert_PIF(!dap_ledger_tx_add(a_ledger, l_btx_addr2, &l_btx_addr2_hash, false, NULL),
"Can't add base tx in white address");
//Check tx in addr from block list
dap_chain_datum_tx_t *l_tx_to_addr1 = dap_ledger_test_create_tx(l_addr_4->enc_key, &l_btx_addr2_hash,
l_addr_1->addr, dap_chain_uint256_from(s_total_supply));
dap_hash_fast_t l_tx_addr1_hash = {0};
dap_hash_fast(l_tx_to_addr1, dap_chain_datum_tx_get_size(l_tx_to_addr1), &l_tx_addr1_hash);
dap_assert(dap_ledger_tx_add(a_ledger, l_tx_to_addr1, &l_tx_addr1_hash, false), "Transfer test to a forbidden address.");
dap_assert(dap_ledger_tx_add(a_ledger, l_tx_to_addr1, &l_tx_addr1_hash, false, NULL), "Transfer test to a forbidden address.");
//Check tx in addr from list
dap_chain_datum_tx_t *l_tx_to_addr3 = dap_ledger_test_create_tx(l_addr_4->enc_key, &l_tx_addr1_hash,
l_addr_3->addr, dap_chain_uint256_from(s_total_supply));
dap_hash_fast_t l_tx_addr3_hash = {0};
dap_hash_fast(l_tx_to_addr3, dap_chain_datum_tx_get_size(l_tx_to_addr3), &l_tx_addr3_hash);
dap_assert(dap_ledger_tx_add(a_ledger, l_tx_to_addr3, &l_tx_addr3_hash, false), "Transfer test to a not forbidden address.");
dap_assert(dap_ledger_tx_add(a_ledger, l_tx_to_addr3, &l_tx_addr3_hash, false, NULL), "Transfer test to a not forbidden address.");
}
}
......@@ -1041,7 +1041,7 @@ void dap_ledger_test_run(void){
dap_hash_fast_t l_hash_btx = {0};
dap_hash_fast(l_base_tx, l_base_tx_size, &l_hash_btx);
dap_assert_PIF(!dap_ledger_tx_add_check(l_ledger, l_base_tx, l_base_tx_size, &l_hash_btx), "Check can added base tx in ledger");
dap_assert_PIF(!dap_ledger_tx_add(l_ledger, l_base_tx, &l_hash_btx, false), "Added base tx in ledger.");
dap_assert_PIF(!dap_ledger_tx_add(l_ledger, l_base_tx, &l_hash_btx, false, NULL), "Added base tx in ledger.");
uint256_t l_balance_example = dap_chain_uint256_from(s_standard_value_tx);
uint256_t l_balance = dap_ledger_calc_balance(l_ledger, &l_addr, s_token_ticker);
uint256_t l_fee = dap_chain_uint256_from(s_fee);
......@@ -1057,7 +1057,7 @@ void dap_ledger_test_run(void){
if (dap_ledger_tx_add_check(l_ledger, l_base_tx_second, l_base_tx_size2, &l_hash_btx_second)) {
dap_pass_msg("Checking can added second base tx in ledger");
}
if (dap_ledger_tx_add(l_ledger, l_base_tx_second, &l_hash_btx_second, false)){
if (dap_ledger_tx_add(l_ledger, l_base_tx_second, &l_hash_btx_second, false, NULL)){
dap_pass_msg("Checking for a failure to add a second base transaction for the same issue to the ledger.");
} else {
dap_fail("Checking for a failure to add a second base transaction for the same issue to the ledger.");
......
modules/common/dap_chain_datum.c
View file @ 63c82b97
......@@ -150,7 +150,7 @@ void dap_datum_token_dump_tsd_to_json(json_object * json_obj_out, dap_chain_datu
DAP_DEL_Z(balance);
}continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_ADD :
json_object_object_add(json_obj_out, "datum_type_allowed_add", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
json_object_object_add(json_obj_out, "datum_type_allowed_add", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_REMOVE :
json_object_object_add(json_obj_out, "datum_type_allowed_remove", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
......@@ -161,30 +161,38 @@ void dap_datum_token_dump_tsd_to_json(json_object * json_obj_out, dap_chain_datu
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_REMOVE:
json_object_object_add(json_obj_out, "datum_type_blocked_remove", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD:
json_object_object_add(json_obj_out, "tx_sender_allowed_add", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_REMOVE:
json_object_object_add(json_obj_out, "tx_sender_allowed_remove", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD:
json_object_object_add(json_obj_out, "tx_sender_blocked_add", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_REMOVE:
json_object_object_add(json_obj_out, "tx_sender_blocked_remove", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
json_object_object_add(json_obj_out, "tx_receiver_allowed_add", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_REMOVE:
json_object_object_add(json_obj_out, "tx_receiver_allowed", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD:
json_object_object_add(json_obj_out, "tx_receiver_blocked_add", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_REMOVE:
json_object_object_add(json_obj_out, "tx_receiver_blocked_remove", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_sender_allowed_add", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_REMOVE:{
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_sender_allowed_remove", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_sender_blocked_add", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_REMOVE: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_sender_blocked_remove", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_receiver_allowed_add", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_REMOVE: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_receiver_allowed", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_receiver_blocked_add", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_REMOVE: {
dap_chain_addr_t *l_addr = dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(json_obj_out, "tx_receiver_blocked_remove", json_object_new_string(dap_chain_addr_to_str_static(l_addr)));
} continue;
case DAP_CHAIN_DATUM_TOKEN_TSD_TOKEN_DESCRIPTION:
json_object_object_add(json_obj_out, "description", json_object_new_string(dap_tsd_get_string_const(l_tsd)));
continue;
......@@ -198,313 +206,6 @@ void dap_datum_token_dump_tsd_to_json(json_object * json_obj_out, dap_chain_datu
}
}
/**
* @brief _dap_chain_datum_tx_out_data
*
* @param a_datum
* @param a_ledger
* @param a_str_out
* @param a_hash_out_type
* @param save_processed_tx
* @param a_tx_hash_processed
* @param l_tx_num
*/
bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
const char *a_ticker,
dap_string_t *a_str_out,
const char *a_hash_out_type,
dap_hash_fast_t *a_tx_hash,
dap_chain_net_id_t a_net_id)
{
bool l_is_first = false;
dap_chain_tx_in_t *l_in_item = (dap_chain_tx_in_t *)dap_chain_datum_tx_item_get(a_datum, NULL, NULL, TX_ITEM_TYPE_IN, NULL);
if (l_in_item && dap_hash_fast_is_blank(&l_in_item->header.tx_prev_hash))
l_is_first = true;
char l_tmp_buf[DAP_TIME_STR_SIZE];
const char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(a_tx_hash)
: dap_chain_hash_fast_to_str_static(a_tx_hash);
dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, a_datum->header.ts_created);
dap_string_append_printf(a_str_out, "transaction:%s hash %s\n TS Created: %s%s%s\n Items:\n",
l_is_first ? " (emit)" : "", l_hash_str, l_tmp_buf,
a_ticker ? " Token ticker: " : "", a_ticker ? a_ticker : "");
dap_hash_fast_t l_hash_tmp = { };
byte_t *item; size_t l_size;
TX_ITEM_ITER_TX(item, l_size, a_datum) {
switch (*item) {
case TX_ITEM_TYPE_IN:
l_hash_tmp = ((dap_chain_tx_in_t*)item)->header.tx_prev_hash;
l_hash_str = !dap_hash_fast_is_blank(&l_hash_tmp)
? dap_strcmp(a_hash_out_type, "hex") ? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp) : dap_chain_hash_fast_to_str_static(&l_hash_tmp)
: "BLANK";
dap_string_append_printf(a_str_out, "\t IN:\nTx_prev_hash: %s\n"
"\t\t Tx_out_prev_idx: %u\n",
l_hash_str,
((dap_chain_tx_in_t*)item)->header.tx_out_prev_idx);
break;
case TX_ITEM_TYPE_OUT_OLD: {
const char *l_value_str = dap_uint256_to_char(
dap_chain_uint256_from(((dap_chain_tx_out_old_t*)item)->header.value), NULL );
dap_string_append_printf(a_str_out, "\t OUT OLD (64):\n"
"\t\t Value: %s (%"DAP_UINT64_FORMAT_U")\n"
"\t\t Address: %s\n",
l_value_str,
((dap_chain_tx_out_old_t*)item)->header.value,
dap_chain_addr_to_str_static(&((dap_chain_tx_out_old_t*)item)->addr));
} break;
case TX_ITEM_TYPE_OUT: { // 256
const char *l_coins_str,
*l_value_str = dap_uint256_to_char(((dap_chain_tx_out_t*)item)->header.value, &l_coins_str),
*l_addr_str = dap_chain_addr_to_str_static(&((dap_chain_tx_out_t*)item)->addr);
dap_string_append_printf(a_str_out, "\t OUT:\n"
"\t\t Value: %s (%s)\n"
"\t\t Address: %s\n",
l_coins_str,
l_value_str,
l_addr_str);
} break;
case TX_ITEM_TYPE_IN_EMS: {
l_hash_tmp = ((dap_chain_tx_in_ems_t*)item)->header.token_emission_hash;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp)
: dap_chain_hash_fast_to_str_static(&l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN_EMS:\n"
"\t\t ticker: %s \n"
"\t\t token_emission_hash: %s\n"
"\t\t token_emission_chain_id: 0x%016"DAP_UINT64_FORMAT_x"\n",
((dap_chain_tx_in_ems_t*)item)->header.ticker,
l_hash_str,
((dap_chain_tx_in_ems_t*)item)->header.token_emission_chain_id.uint64);
} break;
/*
case TX_ITEM_TYPE_IN_EMS_EXT: {
l_hash_tmp = &((dap_chain_tx_in_ems_ext_t*)item)->header.ext_tx_hash;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
: dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN_EMS EXT:\n"
"\t\t Version: %u\n"
"\t\t Ticker: %s\n"
"\t\t Ext chain id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t Ext net id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t Ext tx hash: %s\n"
"\t\t Ext tx out idx: %u\n",
((dap_chain_tx_in_ems_ext_t*)item)->header.version,
((dap_chain_tx_in_ems_ext_t*)item)->header.ticker,
((dap_chain_tx_in_ems_ext_t*)item)->header.ext_chain_id.uint64,
((dap_chain_tx_in_ems_ext_t*)item)->header.ext_net_id.uint64,
l_hash_str,
((dap_chain_tx_in_ems_ext_t*)item)->header.ext_tx_out_idx);
DAP_DELETE(l_hash_str);
} break; */
case TX_ITEM_TYPE_IN_REWARD: {
l_hash_tmp = ((dap_chain_tx_in_reward_t *)item)->block_hash;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp)
: dap_chain_hash_fast_to_str_static(&l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN_REWARD:\n"
"\t\t block_hash: %s\n",
l_hash_str);
} break;
case TX_ITEM_TYPE_SIG: {
dap_sign_t *l_sign = dap_chain_datum_tx_item_sign_get_sig((dap_chain_tx_sig_t*)item);
dap_sign_get_information(l_sign, a_str_out, a_hash_out_type);
dap_chain_addr_t l_sender_addr;
dap_chain_addr_fill_from_sign(&l_sender_addr, l_sign, a_net_id);
dap_string_append_printf(a_str_out, "\tSender addr: %s\n", dap_chain_addr_to_str_static(&l_sender_addr));
} break;
case TX_ITEM_TYPE_RECEIPT: {
const char *l_coins_str, *l_value_str = dap_uint256_to_char(((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi, &l_coins_str);
dap_string_append_printf(a_str_out, "\t Receipt:\n"
"\t\t size: %"DAP_UINT64_FORMAT_U"\n"
"\t\t ext size: %"DAP_UINT64_FORMAT_U"\n"
"\t\t Info:"
"\t\t\t units: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t units type: %s \n"
"\t\t\t value: %s (%s)\n",
((dap_chain_datum_tx_receipt_t*)item)->size,
((dap_chain_datum_tx_receipt_t*)item)->exts_size,
((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units,
((dap_chain_datum_tx_receipt_t*)item)->receipt_info.srv_uid.uint64,
dap_chain_srv_unit_enum_to_str(((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units_type.enm),
l_coins_str,
l_value_str);
dap_string_append_printf(a_str_out, "Exts:\n");
switch ( ((dap_chain_datum_tx_receipt_t*)item)->exts_size ) {
case (sizeof(dap_sign_t) * 2): {
dap_sign_t *l_client = DAP_CAST_PTR( dap_sign_t, ((dap_chain_datum_tx_receipt_t*)item)->exts_n_signs + sizeof(dap_sign_t) );
dap_string_append_printf(a_str_out, " Client:\n");
dap_sign_get_information(l_client, a_str_out, a_hash_out_type);
}
case (sizeof(dap_sign_t)): {
dap_sign_t *l_provider = DAP_CAST_PTR( dap_sign_t, ((dap_chain_datum_tx_receipt_t*)item)->exts_n_signs );
dap_string_append_printf(a_str_out, " Provider:\n");
dap_sign_get_information(l_provider, a_str_out, a_hash_out_type);
break;
}
}
} break;
case TX_ITEM_TYPE_PKEY: {
dap_pkey_t *l_pkey = (dap_pkey_t*)((dap_chain_tx_pkey_t*)item)->pkey;
dap_chain_hash_fast_t l_pkey_hash;
dap_hash_fast(l_pkey->pkey, l_pkey->header.size, &l_pkey_hash);
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? 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(a_str_out, "\t PKey: \n"
"\t\t SIG type: %s\n"
"\t\t SIG size: %u\n"
"\t\t Sequence number: %u \n"
"\t\t Key: \n"
"\t\t\t Type: %s\n"
"\t\t\t Size: %u\n"
"\t\t\t Hash: %s\n",
dap_sign_type_to_str(((dap_chain_tx_pkey_t*)item)->header.sig_type),
((dap_chain_tx_pkey_t*)item)->header.sig_size,
((dap_chain_tx_pkey_t*)item)->seq_no,
dap_pkey_type_to_str(l_pkey->header.type),
l_pkey->header.size,
l_hash_str);
} break;
case TX_ITEM_TYPE_TSD: {
dap_string_append_printf(a_str_out, "\t TSD data: \n"
"\t\t type: %d\n"
"\t\t size: %lu\n",
((dap_chain_tx_tsd_t*)item)->header.type,
((dap_chain_tx_tsd_t*)item)->header.size);
} break;
case TX_ITEM_TYPE_IN_COND:
l_hash_tmp = ((dap_chain_tx_in_cond_t*)item)->header.tx_prev_hash;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp)
: dap_chain_hash_fast_to_str_static(&l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN COND:\n\t\tReceipt_idx: %u\n"
"\t\t Tx_prev_hash: %s\n"
"\t\t Tx_out_prev_idx: %u\n",
((dap_chain_tx_in_cond_t*)item)->header.receipt_idx,
l_hash_str,
((dap_chain_tx_in_cond_t*)item)->header.tx_out_prev_idx);
break;
case TX_ITEM_TYPE_OUT_COND: {
const char *l_coins_str, *l_value_str = dap_uint256_to_char(((dap_chain_tx_out_cond_t*)item)->header.value, &l_coins_str);
dap_time_t l_ts_exp = ((dap_chain_tx_out_cond_t*)item)->header.ts_expires;
dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_ts_exp);
dap_string_append_printf(a_str_out, "\t OUT COND:\n"
"\t Header:\n"
"\t\t ts_expires: %s"
"\t\t value: %s (%s)\n"
"\t\t subtype: %s\n"
"\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n",
l_ts_exp ? l_tmp_buf : "never\n", l_coins_str, l_value_str,
dap_chain_tx_out_cond_subtype_to_str(((dap_chain_tx_out_cond_t*)item)->header.subtype),
((dap_chain_tx_out_cond_t*)item)->header.srv_uid.uint64);
switch (((dap_chain_tx_out_cond_t*)item)->header.subtype) {
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY: {
const char *l_coins_str, *l_value_str =
dap_uint256_to_char( ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi, &l_coins_str );
l_hash_tmp = ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp)
: dap_chain_hash_fast_to_str_static(&l_hash_tmp);
dap_string_append_printf(a_str_out, "\t\t\t unit: 0x%08x\n"
"\t\t\t pkey: %s\n"
"\t\t\t max price: %s (%s)\n",
((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit.uint32,
l_hash_str,
l_coins_str,
l_value_str);
} break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE: {
dap_chain_node_addr_t *l_signer_node_addr = &((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake_pos_delegate.signer_node_addr;
dap_chain_addr_t *l_signing_addr = &((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake_pos_delegate.signing_addr;
l_hash_tmp = l_signing_addr->data.hash_fast;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp)
: dap_chain_hash_fast_to_str_static(&l_hash_tmp);
dap_string_append_printf(a_str_out, "\t\t\t signing_addr: %s\n"
"\t\t\t with pkey hash %s\n"
"\t\t\t signer_node_addr: "NODE_ADDR_FP_STR"\n",
dap_chain_addr_to_str_static(l_signing_addr),
l_hash_str,
NODE_ADDR_FP_ARGS(l_signer_node_addr));
} break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE: {
const char *l_rate_str, *l_tmp_str =
dap_uint256_to_char( (((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.rate), &l_rate_str );
dap_string_append_printf(a_str_out, "\t\t\t net id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t buy_token: %s\n"
"\t\t\t rate: %s\n",
((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.buy_net_id.uint64,
((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.buy_token,
l_rate_str);
} break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK: {
dap_time_t l_ts_unlock = ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake_lock.time_unlock;
dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_ts_unlock);
dap_string_append_printf(a_str_out, "\t\t\t time_unlock %s\n", l_tmp_buf);
} break;
default: break;
}
} break;
case TX_ITEM_TYPE_OUT_EXT: {
const char *l_coins_str, *l_value_str = dap_uint256_to_char( ((dap_chain_tx_out_ext_t*)item)->header.value, &l_coins_str);
dap_string_append_printf(a_str_out, "\t OUT EXT:\n"
"\t\t Addr: %s\n"
"\t\t Token: %s\n"
"\t\t Value: %s (%s)\n",
dap_chain_addr_to_str_static(&((dap_chain_tx_out_ext_t*)item)->addr),
((dap_chain_tx_out_ext_t*)item)->token,
l_coins_str,
l_value_str);
} break;
case TX_ITEM_TYPE_VOTING:{
size_t l_tsd_size = 0;
dap_chain_tx_tsd_t *l_item = (dap_chain_tx_tsd_t *)dap_chain_datum_tx_item_get(a_datum, NULL, (byte_t*)item + l_size, TX_ITEM_TYPE_TSD, &l_tsd_size);
if (!l_item || !l_tsd_size)
break;
dap_chain_datum_tx_voting_params_t *l_voting_params = dap_chain_voting_parse_tsd(a_datum);
dap_string_append_printf(a_str_out, "\t VOTING:\n\tVoting question: %s\n\t Answer options:\n", l_voting_params->voting_question);
dap_list_t *l_temp = l_voting_params->answers_list;
uint8_t l_index = 0;
while (l_temp){
dap_string_append_printf(a_str_out, "\t\t %i) %s\n", l_index, (char*)l_temp->data);
l_index++;
l_temp = l_temp->next;
}
if (l_voting_params->voting_expire) {
dap_time_to_str_rfc822(l_tmp_buf, DAP_TIME_STR_SIZE, l_voting_params->voting_expire);
dap_string_append_printf(a_str_out, "\t Voting expire: %s\n", l_tmp_buf);
}
if (l_voting_params->votes_max_count)
dap_string_append_printf(a_str_out, "\t Votes max count: %"DAP_UINT64_FORMAT_U"\n", l_voting_params->votes_max_count);
dap_string_append_printf(a_str_out, "\t Changing vote is %s available.\n", l_voting_params->vote_changing_allowed ? "" : "not");
dap_string_append_printf(a_str_out, "\t A delegated key is%s required to participate in voting. \n",
l_voting_params->delegate_key_required ? "" : " not");
dap_list_free_full(l_voting_params->answers_list, NULL);
DAP_DELETE(l_voting_params->voting_question);
DAP_DELETE(l_voting_params);
} break;
case TX_ITEM_TYPE_VOTE:{
dap_chain_tx_vote_t *l_vote_item = (dap_chain_tx_vote_t *)item;
const char *l_hash_str = dap_chain_hash_fast_to_str_static(&l_vote_item->voting_hash);
dap_string_append_printf(a_str_out, "\t VOTE: \n"
"\t Voting hash: %s\n"
"\t Vote answer idx: %"DAP_UINT64_FORMAT_U"\n", l_hash_str, l_vote_item->answer_idx);
} break;
default:
dap_string_append_printf(a_str_out, " This transaction have unknown item type \n");
break;
}
}
dap_string_append_printf(a_str_out, "\n");
return true;
}
/**
* @brief _dap_chain_datum_tx_out_data
*
......@@ -583,27 +284,6 @@ bool dap_chain_datum_dump_tx_json(dap_chain_datum_tx_t *a_datum,
sprintf(l_tmp_buff,"0x%016"DAP_UINT64_FORMAT_x"",((dap_chain_tx_in_ems_t*)item)->header.token_emission_chain_id.uint64);
json_object_object_add(json_obj_item,"token_emission_chain_id", json_object_new_string(l_tmp_buff));
} break;
/*
case TX_ITEM_TYPE_IN_EMS_EXT: {
l_hash_tmp = &((dap_chain_tx_in_ems_ext_t*)item)->header.ext_tx_hash;
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str(l_hash_tmp)
: dap_chain_hash_fast_to_str_new(l_hash_tmp);
dap_string_append_printf(a_str_out, "\t IN_EMS EXT:\n"
"\t\t Version: %u\n"
"\t\t Ticker: %s\n"
"\t\t Ext chain id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t Ext net id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t Ext tx hash: %s\n"
"\t\t Ext tx out idx: %u\n",
((dap_chain_tx_in_ems_ext_t*)item)->header.version,
((dap_chain_tx_in_ems_ext_t*)item)->header.ticker,
((dap_chain_tx_in_ems_ext_t*)item)->header.ext_chain_id.uint64,
((dap_chain_tx_in_ems_ext_t*)item)->header.ext_net_id.uint64,
l_hash_str,
((dap_chain_tx_in_ems_ext_t*)item)->header.ext_tx_out_idx);
DAP_DELETE(l_hash_str);
} break; */
case TX_ITEM_TYPE_IN_REWARD: {
l_hash_tmp = ((dap_chain_tx_in_reward_t *)item)->block_hash;
......@@ -678,7 +358,7 @@ bool dap_chain_datum_dump_tx_json(dap_chain_datum_tx_t *a_datum,
l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_hash_tmp)
: dap_chain_hash_fast_to_str_static(&l_hash_tmp);
json_object_object_add(json_obj_item,"Receipt_idx", json_object_new_uint64(((dap_chain_tx_in_cond_t*)item)->header.receipt_idx));
json_object_object_add(json_obj_item,"Receipt_idx", json_object_new_int(((dap_chain_tx_in_cond_t*)item)->header.receipt_idx));
json_object_object_add(json_obj_item,"Tx_prev_hash", json_object_new_string(l_hash_str));
json_object_object_add(json_obj_item,"Tx_out_prev_idx", json_object_new_uint64(((dap_chain_tx_in_cond_t*)item)->header.tx_out_prev_idx));
break;
......
modules/common/dap_chain_datum_decree.c
View file @ 63c82b97
......@@ -255,6 +255,7 @@ void dap_chain_datum_decree_dump_json(json_object *a_json_out, dap_chain_datum_d
? dap_enc_base58_encode_hash_to_str_static(&l_pkey_signing)
: dap_chain_hash_fast_to_str_static(&l_pkey_signing);
json_object_object_add(a_json_out, "Signing pkey fingerprint", json_object_new_string(l_pkey_signing_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR:
if(l_tsd->size > sizeof(dap_chain_node_addr_t)){
json_object_object_add(a_json_out, "Node addr", json_object_new_string("WRONG SIZE"));
......
modules/common/dap_chain_datum_tx_items.c
View file @ 63c82b97
......@@ -536,6 +536,8 @@ uint8_t *dap_chain_datum_tx_item_get_nth(dap_chain_datum_tx_t *a_tx, dap_chain_t
*/
dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_subtype_t a_cond_subtype, int *a_out_num)
{
if (!a_tx)
return NULL;
int l_idx = a_out_num && *a_out_num > 0 ? -*a_out_num : 0;
byte_t *l_item; size_t l_tx_item_size;
TX_ITEM_ITER_TX(l_item, l_tx_item_size, a_tx) {
......
modules/common/include/dap_chain_common.h
View file @ 63c82b97
......@@ -75,6 +75,20 @@ typedef union dap_chain_node_role{
uint8_t raw[DAP_CHAIN_NODE_ROLE_SIZE];
} DAP_ALIGN_PACKED dap_chain_node_role_t;
DAP_STATIC_INLINE const char *dap_chain_node_role_to_str(dap_chain_node_role_t a_node_role)
{
switch (a_node_role.enums) {
case NODE_ROLE_ROOT_MASTER: return "NODE_ROLE_ROOT_MASTER";
case NODE_ROLE_ROOT: return "NODE_ROLE_ROOT";
case NODE_ROLE_ARCHIVE: return "NODE_ROLE_ARCHIVE";
case NODE_ROLE_CELL_MASTER: return "NODE_ROLE_CELL_MASTER";
case NODE_ROLE_MASTER: return "NODE_ROLE_MASTER";
case NODE_ROLE_FULL: return "NODE_ROLE_FULL";
case NODE_ROLE_LIGHT: return "NODE_ROLE_LIGHT";
default: return "UNDEFINED";
}
}
typedef dap_stream_node_addr_t dap_chain_node_addr_t;
#define dap_chain_node_addr_str_check dap_stream_node_addr_str_check
#define dap_chain_node_addr_from_str dap_stream_node_addr_from_str
......
modules/common/include/dap_chain_datum.h
View file @ 63c82b97
......@@ -159,13 +159,6 @@ DAP_STATIC_INLINE const char *dap_chain_datum_type_id_to_str(uint16_t a_type_id)
}
void dap_datum_token_dump_tsd_to_json(json_object * json_obj_out, dap_chain_datum_token_t *a_token, size_t a_token_size, const char *a_hash_out_type);
void dap_chain_datum_dump(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, const char *a_hash_out_type, dap_chain_net_id_t a_net_id);
bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
const char *a_ticker,
dap_string_t *a_str_out,
const char *a_hash_out_type,
dap_hash_fast_t *a_tx_hash,
dap_chain_net_id_t a_net_id);
bool dap_chain_datum_dump_tx_json(dap_chain_datum_tx_t *a_datum,
const char *a_ticker,
json_object* json_obj_out,
......
modules/common/include/dap_chain_datum_token.h
View file @ 63c82b97
......@@ -33,6 +33,7 @@
#include "json_object.h"
#define DAP_CHAIN_DATUM_NONCE_SIZE 64
// Token declaration
typedef struct dap_chain_datum_token_old {
uint16_t type;
......@@ -124,8 +125,9 @@ typedef struct dap_chain_datum_token {
uint256_t premine_supply;
dap_chain_addr_t premine_address;
} DAP_ALIGN_PACKED header_public;
byte_t header[256]; // For future changes
byte_t header[192]; // For future changes
};
uint8_t nonce[DAP_CHAIN_DATUM_NONCE_SIZE];
byte_t tsd_n_signs[]; // Signs and/or types-size-data sections
} DAP_ALIGN_PACKED dap_chain_datum_token_t;
......@@ -293,7 +295,6 @@ uint32_t dap_chain_datum_token_flag_from_str(const char *a_str);
#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_REMOVE 0x0024
#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_CLEAR 0x0025
#define DAP_CHAIN_DATUM_NONCE_SIZE 64
// Get delegated ticker
DAP_STATIC_INLINE int dap_chain_datum_token_get_delegated_ticker(char *a_buf, const char *a_ticker)
......
modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
View file @ 63c82b97
......@@ -85,10 +85,10 @@ static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a
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(dap_chain_cs_dag_poa_round_item_t *a_arg);
static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_size);
const char *a_key, const void *a_value, const size_t a_value_size, bool a_by_us);
static bool s_round_event_ready_minimum_check(dap_chain_cs_dag_t *a_dag, dap_chain_cs_dag_event_t *a_event,
size_t a_event_size, char *a_event_hash_hex_str);
static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_item);
static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_item, uint32_t a_timeout_s);
// CLI commands
static int s_cli_dag_poa(int argc, char ** argv, void **a_str_reply);
......@@ -291,7 +291,7 @@ static int s_cli_dag_poa(int argc, char ** argv, void **a_str_reply)
.datum_hash = l_round_item->round_info.datum_hash,
.dag = l_dag
};
s_round_event_cs_done(&l_event_item);
s_round_event_cs_done(&l_event_item, l_poa_pvt->confirmations_timeout);
}
} else {
if(!dap_strcmp(l_hash_out_type, "hex")) {
......@@ -392,6 +392,10 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
}
}
}
if (!l_poa_pvt->auth_certs_count) {
log_it(L_ERROR, "Can't find any cert in \"dag_poa\" consensus");
return -1;
}
log_it(L_NOTICE,"Initialized DAG-PoA consensus with %u/%u minimum consensus",l_poa_pvt->auth_certs_count,l_poa_pvt->auth_certs_count_verify);
l_dag->chain->callback_created = s_callback_created;
......@@ -604,8 +608,7 @@ static bool s_callback_round_event_to_chain_callback_get_round_item(dap_global_d
}
}
} else /* !l_chosen_item */
log_it(L_WARNING, "No valid candidates to wrap datum %s in current round #%"DAP_UINT64_FORMAT_U"",
l_datum_hash_str, l_dag->round_id);
log_it(L_WARNING, "No valid candidates to wrap datum %s in current round", l_datum_hash_str);
return DAP_DELETE(l_arg), true;
}
......@@ -620,7 +623,7 @@ static bool s_callback_round_event_to_chain(dap_chain_cs_dag_poa_round_item_t *a
false;
}
static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_item)
static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_item, uint32_t a_timeout_s)
{
dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT( DAP_CHAIN_CS_DAG_POA(a_event_item->dag) );
dap_chain_cs_dag_poa_round_item_t *l_event_item = NULL;
......@@ -628,11 +631,11 @@ static void s_round_event_cs_done(dap_chain_cs_dag_poa_round_item_t *a_event_ite
HASH_FIND(hh, l_poa_pvt->event_items, &a_event_item->datum_hash, sizeof(dap_hash_fast_t), l_event_item);
if (!l_event_item) {
l_event_item = DAP_DUP(a_event_item);
if ( !dap_timerfd_start(l_poa_pvt->confirmations_timeout * 1000, (dap_timerfd_callback_t)s_callback_round_event_to_chain, l_event_item) )
if ( !dap_timerfd_start(a_timeout_s * 1000, (dap_timerfd_callback_t)s_callback_round_event_to_chain, l_event_item) )
return DAP_DELETE(l_event_item), pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock), log_it(L_CRITICAL, "Timer creation failed");
HASH_ADD(hh, l_poa_pvt->event_items, datum_hash, sizeof(dap_hash_fast_t), l_event_item);
log_it(L_INFO, "Confirmation timer for datum %s started [%d s]",
dap_chain_hash_fast_to_str_static(&l_event_item->datum_hash), l_poa_pvt->confirmations_timeout);
dap_chain_hash_fast_to_str_static(&l_event_item->datum_hash), a_timeout_s);
}
pthread_rwlock_unlock(&l_poa_pvt->rounds_rwlock);
}
......@@ -643,7 +646,7 @@ static bool s_callback_sync_all_on_start(dap_global_db_instance_t *a_dbi, int a_
{
for (size_t i = 0; i < a_values_count; i++)
s_callback_event_round_sync((dap_chain_cs_dag_t *)a_arg, DAP_GLOBAL_DB_OPTYPE_ADD, a_group,
a_values[i].key, a_values[i].value, a_values[i].value_len);
a_values[i].key, a_values[i].value, a_values[i].value_len, true);
return false;
}
......@@ -659,7 +662,8 @@ static void s_round_changes_notify(dap_store_obj_t *a_obj, void *a_arg)
return;
switch ( l_type ) {
case DAP_GLOBAL_DB_OPTYPE_ADD:
s_callback_event_round_sync(l_dag, l_type, a_obj->group, a_obj->key, a_obj->value, a_obj->value_len);
s_callback_event_round_sync(l_dag, l_type, a_obj->group, a_obj->key, a_obj->value, a_obj->value_len,
dap_stream_node_addr_from_sign(a_obj->sign).uint64 == g_node_addr.uint64);
default:
break;
}
......@@ -699,7 +703,6 @@ static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_net_c
dap_global_db_cluster_add_notify_callback(l_dag_cluster, s_round_changes_notify, l_dag);
dap_chain_net_add_auth_nodes_to_cluster(l_net, l_dag_cluster);
dap_link_manager_add_net_associate(l_net->pub.id.uint64, l_dag_cluster->links_cluster);
l_dag->round_id = 0;
PVT(l_poa)->mempool_timer = dap_interval_timer_create(15000, s_timer_process_callback, a_chain);
switch ( dap_chain_net_get_role(l_net).enums ) {
......@@ -762,11 +765,11 @@ static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a
log_it(L_ERROR, "Can't sign event with events_sign_cert in [dag-poa] section");
else if ( s_seed_mode || (a_hashes && a_hashes_count) ) {
if ( !PVT(l_poa)->callback_pre_sign || !PVT(l_poa)->callback_pre_sign->callback) {
return dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_dag->round_id,
a_datum, PVT(l_poa)->events_sign_cert->enc_key,
a_hashes, a_hashes_count, a_event_size);
return dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id, a_datum,
PVT(l_poa)->events_sign_cert->enc_key,
a_hashes, a_hashes_count, a_event_size);
} else {
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_id,
dap_chain_cs_dag_event_t *l_event = dap_chain_cs_dag_event_new(a_dag->chain->id, a_dag->chain->cells->id,
a_datum, NULL, a_hashes, a_hashes_count, a_event_size);
if ( PVT(l_poa)->callback_pre_sign->callback(a_dag->chain, l_event, *a_event_size, PVT(l_poa)->callback_pre_sign->arg) )
return DAP_DELETE(l_event), NULL;
......@@ -778,7 +781,7 @@ static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a
}
static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_size)
const char *a_key, const void *a_value, const size_t a_value_size, bool a_by_us)
{
dap_return_val_if_pass(a_op_code != DAP_GLOBAL_DB_OPTYPE_ADD || !a_key || !a_value
|| !a_value_size || !strcmp(DAG_ROUND_CURRENT_KEY, a_key), 0);
......@@ -792,39 +795,35 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
if (!l_poa_pvt->auto_confirmation)
return 0;
dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t *)a_value;
dap_chain_cs_dag_event_round_item_t *l_round_item = (dap_chain_cs_dag_event_round_item_t*)a_value;
dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t*)l_round_item->event_n_signs;
size_t l_event_size = l_round_item->event_size;
dap_chain_cs_dag_event_t *l_event = (dap_chain_cs_dag_event_t*)DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
if (!l_event)
return log_it(L_CRITICAL, "Memory allocation failed"), -1;
if ( dap_chain_cs_dag_event_sign_exists(l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key)
|| dap_chain_cs_dag_event_round_sign_exists(l_round_item, l_poa_pvt->events_sign_cert->enc_key)
&& l_poa_pvt->auto_round_complete
&& s_round_event_ready_minimum_check(a_dag, l_event, l_event_size, (char*)a_key) )
{
dap_chain_cs_dag_poa_round_item_t l_event_item = { .datum_hash = l_round_item->round_info.datum_hash, .dag = a_dag };
return DAP_DELETE(l_event), s_round_event_cs_done(&l_event_item), 0;
}
size_t l_event_size_new = 0;
int ret = 0;
if ( !l_poa_pvt->callback_pre_sign || !l_poa_pvt->callback_pre_sign->callback
|| !(ret = l_poa_pvt->callback_pre_sign->callback(a_dag->chain, l_event, l_event_size,
l_poa_pvt->callback_pre_sign->arg)) )
{
l_event_size_new = dap_chain_cs_dag_event_sign_add(&l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key);
dap_chain_cs_dag_event_gdb_set(a_dag, (char*)a_key, l_event, l_event_size_new, l_round_item);
} else { // set sign for reject
l_round_item = DAP_DUP_SIZE(a_value, a_value_size);
if (dap_chain_cs_dag_event_round_sign_add(&l_round_item, a_value_size, l_poa_pvt->events_sign_cert->enc_key)) {
log_it(L_NOTICE,"Can't sign event %s, because sign rejected by pre_sign callback, ret code %d", a_key, ret);
l_round_item->round_info.reject_count++;
dap_chain_cs_dag_event_gdb_set(a_dag, (char*)a_key, l_event, l_event_size, l_round_item);
int l_ret = 0;
if ( dap_chain_cs_dag_event_sign_exists(l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key) ) {
if (l_poa_pvt->auto_round_complete && s_round_event_ready_minimum_check(a_dag, l_event, l_event_size, (char*)a_key) ) {
dap_chain_cs_dag_poa_round_item_t l_event_item = { .datum_hash = l_round_item->round_info.datum_hash, .dag = a_dag };
return s_round_event_cs_done(&l_event_item, a_by_us ? l_poa_pvt->confirmations_timeout : 2*l_poa_pvt->confirmations_timeout), l_ret;
}
} else {
if ( !l_poa_pvt->callback_pre_sign
|| !l_poa_pvt->callback_pre_sign->callback
|| !(l_ret = l_poa_pvt->callback_pre_sign->callback(a_dag->chain, l_event, l_event_size, l_poa_pvt->callback_pre_sign->arg))
) {
l_event = DAP_DUP_SIZE(l_round_item->event_n_signs, l_event_size);
if (( l_event_size = dap_chain_cs_dag_event_sign_add(&l_event, l_event_size, l_poa_pvt->events_sign_cert->enc_key) ))
dap_chain_cs_dag_event_gdb_set(a_dag, (char*)a_key, l_event, l_event_size, l_round_item);
DAP_DELETE(l_event);
} else {
l_round_item = DAP_DUP_SIZE(a_value, a_value_size);
if ( dap_chain_cs_dag_event_round_sign_add(&l_round_item, a_value_size, l_poa_pvt->events_sign_cert->enc_key) ) {
log_it(L_NOTICE,"Can't sign event %s, because sign rejected by pre_sign callback, ret code %d", a_key, l_ret);
++l_round_item->round_info.reject_count;
dap_chain_cs_dag_event_gdb_set(a_dag, (char*)a_key, l_event, l_event_size, l_round_item);
}
DAP_DELETE(l_round_item);
}
DAP_DELETE(l_round_item);
}
return DAP_DELETE(l_event), ret;
return l_ret;
}
/**
......
modules/consensus/esbocs/dap_chain_cs_esbocs.c
View file @ 63c82b97
......@@ -207,8 +207,13 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
{
dap_chain_cs_type_create("blocks", a_chain, a_chain_cfg);
//patch for tests
#ifdef DAP_LEDGER_TEST
return 0;
#endif
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
int l_ret = 0;
int l_ret = 0, l_inited_cert;
dap_chain_esbocs_t *l_esbocs = NULL;
DAP_NEW_Z_RET_VAL(l_esbocs, dap_chain_esbocs_t, -5, NULL);
......@@ -232,7 +237,6 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
l_esbocs_pvt->new_round_delay = dap_config_get_item_uint16_default(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "new_round_delay", 10);
l_esbocs_pvt->round_attempts_max = dap_config_get_item_uint16_default(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "round_attempts_max", 4);
l_esbocs_pvt->round_attempt_timeout = dap_config_get_item_uint16_default(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "round_attempt_timeout", 10);
l_esbocs_pvt->start_validators_min = l_esbocs_pvt->min_validators_count =
dap_config_get_item_uint16(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "min_validators_count");
if (!l_esbocs_pvt->min_validators_count) {
......@@ -241,6 +245,10 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
}
const char *l_auth_certs_prefix = dap_config_get_item_str(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "auth_certs_prefix");
if (!l_auth_certs_prefix) {
l_ret = -6;
goto lb_err;
}
uint16_t l_node_addrs_count;
const char **l_addrs = dap_config_get_array_str(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "validators_addrs", &l_node_addrs_count);
if (l_node_addrs_count < l_esbocs_pvt->min_validators_count) {
......@@ -261,11 +269,13 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
log_it(L_ERROR, "Can't find cert \"%s\"", l_cert_name);
else
log_it(L_ERROR, "Can't find cert \"%s\" possibly for address \"%s\"", l_cert_name, l_addrs[i]);
continue;
l_ret = -6;
goto lb_err;
}
}
dap_chain_addr_t l_signing_addr;
log_it(L_NOTICE, "Initialized auth cert \"%s\"", l_cert_name);
l_inited_cert++;
dap_chain_addr_fill_from_key(&l_signing_addr, l_cert_cur->enc_key, a_chain->net_id);
l_esbocs_pvt->emergency_validator_addrs = dap_list_append(l_esbocs_pvt->emergency_validator_addrs,
......@@ -298,6 +308,10 @@ static int s_callback_new(dap_chain_t *a_chain, dap_config_t *a_chain_cfg)
l_weight, &l_signer_node_addr);
}
}
if (!l_inited_cert) {
l_ret = -1;
goto lb_err;
}
// Preset reward for block signs, before first reward decree
const char *l_preset_reward_str = dap_config_get_item_str(a_chain_cfg, DAP_CHAIN_ESBOCS_CS_TYPE_STR, "preset_reward");
if (l_preset_reward_str) {
......
modules/net/dap_chain_ledger.c
View file @ 63c82b97
......@@ -130,6 +130,7 @@ typedef struct dap_ledger_token_item {
time_t last_update_token_time;
// for auth operations
dap_pkey_t ** auth_pkeys;
dap_chain_hash_fast_t *auth_pkey_hashes;
size_t auth_signs_total;
......@@ -1617,7 +1618,8 @@ int dap_ledger_token_add(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token
.token_emissions_rwlock = PTHREAD_RWLOCK_INITIALIZER,
.token_ts_updated_rwlock = PTHREAD_RWLOCK_INITIALIZER,
.auth_pkeys = DAP_NEW_Z_SIZE(dap_pkey_t*, sizeof(dap_pkey_t*) * l_token->signs_total),
.auth_pkey_hashes = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t, sizeof(dap_chain_hash_fast_t) * l_token->signs_total)
.auth_pkey_hashes = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t, sizeof(dap_chain_hash_fast_t) * l_token->signs_total),
.flags = 0
};
switch (l_token->subtype) {
case DAP_CHAIN_DATUM_TOKEN_SUBTYPE_PRIVATE:
......@@ -2145,7 +2147,39 @@ json_object *s_token_item_to_json(dap_ledger_token_item_t *a_token_item)
json_object_object_add(l_json_obj_out, "bytes", json_object_new_int(a_token_item->auth_pkeys[i]->header.size));
json_object_array_add(l_json_arr_pkeys, l_json_obj_out);
}
json_object *l_json_arr_tx_recv_allow = json_object_new_array();
for (size_t i = 0; i < a_token_item->tx_recv_allow_size; i++) {
dap_chain_addr_t l_addr = a_token_item->tx_recv_allow[i];
const char *l_addr_str = dap_chain_addr_to_str_static(&l_addr);
json_object_array_add(l_json_arr_tx_recv_allow, json_object_new_string(l_addr_str));
}
json_object *l_json_arr_tx_recv_block = json_object_new_array();
for (size_t i = 0; i < a_token_item->tx_recv_block_size; i++) {
dap_chain_addr_t l_addr = a_token_item->tx_recv_block[i];
const char *l_addr_str = dap_chain_addr_to_str_static(&l_addr);
json_object_array_add(l_json_arr_tx_recv_block, json_object_new_string(l_addr_str));
}
json_object *l_json_arr_tx_send_allow = json_object_new_array();
for (size_t i = 0; i < a_token_item->tx_send_allow_size; i++) {
dap_chain_addr_t l_addr = a_token_item->tx_send_allow[i];
const char *l_addr_str = dap_chain_addr_to_str_static(&l_addr);
json_object_array_add(l_json_arr_tx_send_allow, json_object_new_string(l_addr_str));
}
json_object *l_json_arr_tx_send_block = json_object_new_array();
for (size_t i = 0; i < a_token_item->tx_send_block_size; i++) {
dap_chain_addr_t l_addr = a_token_item->tx_send_block[i];
const char *l_addr_str = dap_chain_addr_to_str_static(&l_addr);
json_object_array_add(l_json_arr_tx_send_block, json_object_new_string(l_addr_str));
}
json_object_object_add(json_obj_datum, "Signatures public keys", l_json_arr_pkeys);
a_token_item->tx_recv_allow_size ? json_object_object_add(json_obj_datum, "tx_recv_allow", l_json_arr_tx_recv_allow) :
json_object_put(l_json_arr_tx_recv_allow);
a_token_item->tx_recv_block_size ? json_object_object_add(json_obj_datum, "tx_recv_block", l_json_arr_tx_recv_block) :
json_object_put(l_json_arr_tx_recv_block);
a_token_item->tx_send_allow_size ? json_object_object_add(json_obj_datum, "tx_send_allow", l_json_arr_tx_send_allow) :
json_object_put(l_json_arr_tx_send_allow);
a_token_item->tx_send_block_size ? json_object_object_add(json_obj_datum, "tx_send_block", l_json_arr_tx_send_block) :
json_object_put(l_json_arr_tx_send_block);
json_object_object_add(json_obj_datum, "Total emissions", json_object_new_int(HASH_COUNT(a_token_item->token_emissions)));
return json_obj_datum;
}
......@@ -2240,7 +2274,7 @@ static void s_threshold_txs_proc( dap_ledger_t *a_ledger)
l_success = false;
dap_ledger_tx_item_t *l_tx_item, *l_tx_tmp;
HASH_ITER(hh, l_ledger_pvt->threshold_txs, l_tx_item, l_tx_tmp) {
int l_res = dap_ledger_tx_add(a_ledger, l_tx_item->tx, &l_tx_item->tx_hash_fast, true);
int l_res = dap_ledger_tx_add(a_ledger, l_tx_item->tx, &l_tx_item->tx_hash_fast, true, NULL);
if (l_res != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION &&
l_res != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS) {
HASH_DEL(l_ledger_pvt->threshold_txs, l_tx_item);
......@@ -2697,7 +2731,8 @@ int s_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_
pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
if (l_token_emission_item) {
debug_if(s_debug_more, L_WARNING, "Can't add token emission datum of %s %s ( %s ): already present in cache",
dap_uint256_to_char(l_emission->hdr.value, NULL), l_emission->hdr.ticker, dap_chain_hash_fast_to_str_static(a_emission_hash));
dap_uint256_to_char(l_emission->hdr.value, NULL), l_emission->hdr.ticker,
dap_chain_hash_fast_to_str_static(a_emission_hash));
DAP_DELETE(l_emission);
return DAP_LEDGER_CHECK_ALREADY_CACHED;
}
......@@ -4182,7 +4217,7 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
}
if (a_main_ticker && !l_err_num)
dap_strncpy(a_main_ticker, l_main_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
dap_strncpy(a_main_ticker, l_main_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
HASH_DEL(l_values_from_prev_tx, l_value_cur);
......@@ -4276,7 +4311,7 @@ static int s_sort_ledger_tx_item(dap_ledger_tx_item_t *a, dap_ledger_tx_item_t *
* @param a_from_threshold
* @return return 1 OK, -1 error
*/
int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_hash_fast_t *a_tx_hash, bool a_from_threshold)
int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_hash_fast_t *a_tx_hash, bool a_from_threshold, dap_ledger_datum_iter_data_t *a_datum_index_data)
{
if(!a_tx) {
debug_if(s_debug_more, L_ERROR, "NULL tx detected");
......@@ -4299,7 +4334,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
if( (l_ret_check = s_tx_cache_check(a_ledger, a_tx, a_tx_hash, a_from_threshold,
&l_list_bound_items, &l_list_tx_out,
l_main_token_ticker, &l_tag, &l_action, false))) {
l_main_token_ticker, &l_tag, &l_action, false))) {
if ((l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS ||
l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION) &&
l_ledger_pvt->threshold_enabled && !dap_chain_net_get_load_mode(a_ledger->net)) {
......@@ -4312,7 +4347,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
if (!l_item_tmp) {
if (l_threshold_txs_count >= s_threshold_txs_max) {
if(s_debug_more)
log_it(L_WARNING, "Threshold for tranactions is overfulled (%zu max), dropping down tx %s, added nothing",
log_it(L_WARNING, "Threshold for transactions is overfulled (%zu max), dropping down tx %s, added nothing",
s_threshold_txs_max, l_tx_hash_str);
} else {
l_item_tmp = DAP_NEW_Z(dap_ledger_tx_item_t);
......@@ -4347,7 +4382,11 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
return l_ret_check;
}
debug_if(s_debug_more, L_DEBUG, "dap_ledger_tx_add() check passed for tx %s", l_tx_hash_str);
if ( a_datum_index_data != NULL){
dap_strncpy(a_datum_index_data->token_ticker, l_main_token_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
a_datum_index_data->action = l_action;
a_datum_index_data->uid = l_tag;
}
// Mark 'out' items in cache if they were used & delete previous transactions from cache if it need
// find all bound pairs 'in' and 'out'
size_t l_outs_used = dap_list_length(l_list_bound_items);
......@@ -4951,7 +4990,7 @@ FIN:
return l_ret;
}
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)
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, dap_ledger_datum_iter_data_t *a_datum_index_data)
{
#ifndef DAP_LEDGER_TEST
if (dap_chain_net_get_load_mode(a_ledger->net)) {
......@@ -4967,7 +5006,7 @@ int dap_ledger_tx_load(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_c
return DAP_LEDGER_CHECK_ALREADY_CACHED;
}
#endif
return dap_ledger_tx_add(a_ledger, a_tx, a_tx_hash, false);
return dap_ledger_tx_add(a_ledger, a_tx, a_tx_hash, false, a_datum_index_data);
}
/**
......
modules/net/dap_chain_net.c
View file @ 63c82b97
......@@ -184,17 +184,10 @@ typedef struct dap_chain_net_pvt{
anchor_table_t *anchors;
} dap_chain_net_pvt_t;
typedef struct dap_chain_net_item{
char name[DAP_CHAIN_NET_NAME_MAX + 1];
dap_chain_net_id_t net_id;
dap_chain_net_t *chain_net;
UT_hash_handle hh, hh2;
} dap_chain_net_item_t;
#define PVT(a) ((dap_chain_net_pvt_t *)a->pvt)
#define PVT_S(a) ((dap_chain_net_pvt_t *)a.pvt)
static dap_chain_net_item_t *s_net_items = NULL, *s_net_ids = NULL;
static dap_chain_net_t *s_nets_by_name = NULL, *s_nets_by_id = NULL;
static pthread_mutex_t s_net_cond_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_net_cond = PTHREAD_COND_INITIALIZER;
static uint16_t s_net_loading_count = 0;
......@@ -341,13 +334,36 @@ char *dap_chain_net_get_gdb_group_acl(dap_chain_net_t *a_net)
return NULL;
}
DAP_STATIC_INLINE struct request_link_info *s_net_resolve_host(const char *a_addr) {
char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' }; uint16_t l_port = 0;
struct sockaddr_storage l_saddr;
if ( dap_net_parse_config_address(a_addr, l_host, &l_port, NULL, NULL) < 0
|| dap_net_resolve_host(l_host, dap_itoa(l_port), false, &l_saddr, NULL) < 0 )
return NULL;
struct request_link_info *l_ret = DAP_NEW_Z(struct request_link_info);
l_ret->port = l_port;
dap_strncpy(l_ret->addr, l_host, DAP_HOSTADDR_STRLEN);
return l_ret;
}
static struct request_link_info *s_balancer_link_from_cfg(dap_chain_net_t *a_net)
{
uint16_t l_idx;
switch (PVT(a_net)->seed_nodes_count) {
case 0: return log_it(L_ERROR, "No available links in net %s! Add them in net config", a_net->pub.name), NULL;
case 1: return PVT(a_net)->seed_nodes_info[0];
default: return PVT(a_net)->seed_nodes_info[dap_random_uint16() % PVT(a_net)->seed_nodes_count];
case 1:
l_idx = 0;
break;
default:
l_idx = dap_random_uint16() % PVT(a_net)->seed_nodes_count;
break;
}
if ( !PVT(a_net)->seed_nodes_info[l_idx] ) {
// Unresolved before? Let's try again
const char **l_seed_nodes_hosts = dap_config_get_array_str(a_net->pub.config, "general", "seed_nodes_hosts", NULL);
PVT(a_net)->seed_nodes_info[l_idx] = s_net_resolve_host(l_seed_nodes_hosts[l_idx]);
}
return PVT(a_net)->seed_nodes_info[l_idx];
}
dap_chain_node_info_t *dap_chain_net_get_my_node_info(dap_chain_net_t *a_net)
......@@ -371,8 +387,10 @@ dap_stream_node_addr_t *dap_chain_net_get_authorized_nodes(dap_chain_net_t *a_ne
int dap_chain_net_link_add(dap_chain_net_t *a_net, dap_stream_node_addr_t *a_addr, const char *a_host, uint16_t a_port)
{
bool l_is_link_present = dap_link_manager_link_find(a_addr, a_net->pub.id.uint64);
if (l_is_link_present || a_addr->uint64 == g_node_addr.uint64)
if (l_is_link_present || a_addr->uint64 == g_node_addr.uint64) {
debug_if(l_is_link_present, L_DEBUG, "Link to addr "NODE_ADDR_FP_STR" is already persent in net %s", NODE_ADDR_FP_ARGS(a_addr), a_net->pub.name);
return -3; // Link is already found for this net or link is to yourself
}
if (dap_link_manager_link_create(a_addr, a_net->pub.id.uint64)) {
log_it(L_ERROR, "Can't create link to addr " NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS(a_addr));
return -1;
......@@ -446,8 +464,10 @@ static bool s_link_manager_callback_disconnected(dap_link_t *a_link, uint64_t a_
log_it(L_INFO, "%s."NODE_ADDR_FP_STR" can't connect for now. %s", l_net ? l_net->pub.name : "(unknown)" ,
NODE_ADDR_FP_ARGS_S(a_link->addr),
l_link_is_permanent ? "Setting reconnection pause for it." : "Dropping it.");
if (!a_links_count && l_net_pvt->state == NET_STATE_ONLINE)
if (!a_links_count && l_net_pvt->state != NET_STATE_OFFLINE) {
l_net_pvt->state = NET_STATE_LINKS_PREPARE;
s_net_states_proc(l_net);
}
return l_link_is_permanent;
}
......@@ -511,15 +531,15 @@ int s_link_manager_fill_net_info(dap_link_t *a_link)
// sanity check
dap_return_val_if_pass(!a_link, -1);
// func work
dap_chain_net_item_t *l_net_item = NULL, *l_tmp = NULL;
dap_chain_node_info_t *l_node_info = NULL;
HASH_ITER(hh, s_net_items, l_net_item, l_tmp)
if ((l_node_info = dap_chain_node_info_read(l_net_item->chain_net, &a_link->addr)))
for (dap_chain_net_t *net = s_nets_by_name; net; net = net->hh.next) {
if (( l_node_info = dap_chain_node_info_read(net, &a_link->addr) ))
break;
}
if (!l_node_info)
return -3;
a_link->uplink.ready = true;
if (dap_link_manager_link_update(&a_link->addr, l_node_info->ext_host, l_node_info->ext_port))
if ( dap_link_manager_link_update(&a_link->addr, l_node_info->ext_host, l_node_info->ext_port) )
a_link->uplink.ready = true;
DAP_DELETE(l_node_info);
return 0;
......@@ -622,18 +642,35 @@ dap_chain_node_role_t dap_chain_net_get_role(dap_chain_net_t * a_net)
* @param a_node_role
* @return dap_chain_net_t*
*/
static dap_chain_net_t *s_net_new(dap_chain_net_id_t *a_id, const char *a_name,
const char *a_native_ticker, const char *a_node_role)
static dap_chain_net_t *s_net_new(const char *a_net_name, dap_config_t *a_cfg)
{
// sanity check
dap_return_val_if_pass(!a_id || !a_name || !a_native_ticker || !a_node_role, NULL);
dap_return_val_if_fail(a_cfg, NULL);
dap_chain_net_t *l_ret = NULL;
// memory alloc
const char *l_net_name_str = dap_config_get_item_str_default(a_cfg, "general", "name", a_net_name),
*l_net_id_str = dap_config_get_item_str(a_cfg, "general", "id"),
*a_node_role = dap_config_get_item_str(a_cfg, "general", "node-role" ),
*a_native_ticker= dap_config_get_item_str(a_cfg, "general", "native_ticker");
dap_chain_net_id_t l_net_id;
if(!l_net_name_str || !l_net_id_str || dap_chain_net_id_parse(l_net_id_str, &l_net_id))
return log_it(L_ERROR, "Can't create l_net, can't read name or ID config"), NULL;
dap_chain_net_t *l_net_sought = NULL;
HASH_FIND_STR(s_nets_by_name, l_net_name_str, l_net_sought);
if (!l_net_sought)
HASH_FIND(hh2, s_nets_by_id, &l_net_id, sizeof(l_net_id), l_net_sought);
if (l_net_sought) {
log_it(L_ERROR, "Can't create net %s ID %"DAP_UINT64_FORMAT_U", an already existent net "
"%s ID %"DAP_UINT64_FORMAT_U" has the same name or ID.\n"\
"Please, fix your configs and restart node",
l_net_name_str, l_net_id.uint64, l_net_sought->pub.name,
l_net_sought->pub.id.uint64);
return NULL;
}
DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_t, sizeof(dap_chain_net_t) + sizeof(dap_chain_net_pvt_t), NULL, NULL);
DAP_NEW_Z_SIZE_RET_VAL(PVT(l_ret)->node_info, dap_chain_node_info_t, sizeof(dap_chain_node_info_t) + DAP_HOSTADDR_STRLEN + 1, NULL, l_ret);
// func work
l_ret->pub.id.uint64 = a_id->uint64;
l_ret->pub.id = l_net_id;
if (strcmp (a_node_role, "root_master")==0){
PVT(l_ret)->node_role.enums = NODE_ROLE_ROOT_MASTER;
} else if (strcmp( a_node_role,"root") == 0){
......@@ -649,18 +686,49 @@ static dap_chain_net_t *s_net_new(dap_chain_net_id_t *a_id, const char *a_name,
}else if (strcmp( a_node_role,"light") == 0){
PVT(l_ret)->node_role.enums = NODE_ROLE_LIGHT;
}else{
log_it(L_ERROR,"Unknown node role \"%s\" for network '%s'", a_node_role, a_name);
log_it(L_ERROR,"Unknown node role \"%s\" for network '%s'", a_node_role, l_net_name_str);
DAP_DELETE(l_ret);
return NULL;
}
if (!(l_ret->pub.name = dap_strdup(a_name)) ||
!(l_ret->pub.native_ticker = dap_strdup( a_native_ticker )))
DAP_DEL_MULTY(l_ret->pub.name, l_ret->pub.native_ticker, l_ret);
log_it (L_NOTICE, "Node role \"%s\" selected for network '%s'", a_node_role, a_name);
if (!( l_net_name_str ))
return DAP_DELETE(l_ret), log_it(L_ERROR, "Invalid net name, check [general] \"name\" in netconfig"), NULL;
dap_strncpy(l_ret->pub.name, l_net_name_str, sizeof(l_ret->pub.name));
if (!( l_ret->pub.native_ticker = a_native_ticker ))
return DAP_DEL_MULTY(l_ret->pub.name, l_ret),
log_it(L_ERROR, "Invalid native ticker, check [general] \"native_ticker\" in %s.cfg",
l_net_name_str),
NULL;
log_it (L_NOTICE, "Node role \"%s\" selected for network '%s'", a_node_role, l_net_name_str);
l_ret->pub.config = a_cfg;
l_ret->pub.gdb_groups_prefix
= dap_config_get_item_str_default( a_cfg, "general", "gdb_groups_prefix", dap_config_get_item_str(a_cfg, "general", "name") );
HASH_ADD_STR(s_nets_by_name, pub.name, l_ret);
HASH_ADD(hh2, s_nets_by_id, pub.id, sizeof(dap_chain_net_id_t), l_ret);
return l_ret;
}
bool s_net_disk_load_notify_callback(UNUSED_ARG void *a_arg) {
json_object *json_obj = json_object_new_object();
json_object_object_add(json_obj, "class", json_object_new_string("nets_init"));
json_object *l_jobj_nets = json_object_new_object();
for (dap_chain_net_t *net = s_nets_by_name; net; net = net->hh.next) {
json_object *json_chains = json_object_new_object();
for (dap_chain_t *l_chain = net->pub.chains; l_chain; l_chain = l_chain->next) {
json_object *l_jobj_chain_info = json_object_new_object();
json_object_object_add(l_jobj_chain_info, "count_atoms", json_object_new_int(l_chain->callback_count_atom(l_chain)));
json_object_object_add(l_jobj_chain_info, "load_process", json_object_new_int(l_chain->load_progress));
json_object_object_add(json_chains, l_chain->name, l_jobj_chain_info);
log_it(L_DEBUG, "Loading net \"%s\", chain \"%s\", ID 0x%016"DAP_UINT64_FORMAT_x " [%d%%]",
net->pub.name, l_chain->name, l_chain->id.uint64, l_chain->load_progress);
}
json_object_object_add(l_jobj_nets, net->pub.name, json_chains);
}
json_object_object_add(json_obj, "nets", l_jobj_nets);
dap_notify_server_send_mt(json_object_get_string(json_obj));
json_object_put(json_obj);
return true;
}
/**
* @brief
* load network config settings
......@@ -668,35 +736,32 @@ static dap_chain_net_t *s_net_new(dap_chain_net_id_t *a_id, const char *a_name,
void dap_chain_net_load_all()
{
pthread_mutex_lock(&s_net_cond_lock);
s_net_loading_count = HASH_COUNT(s_net_items);
s_net_loading_count = HASH_COUNT(s_nets_by_name);
if (!s_net_loading_count) {
log_it(L_ERROR, "Can't find any nets");
pthread_mutex_unlock(&s_net_cond_lock);
return;
}
dap_chain_net_item_t *l_net_items_current = NULL, *l_net_items_tmp = NULL;
HASH_ITER(hh, s_net_items, l_net_items_current, l_net_items_tmp)
dap_proc_thread_callback_add(NULL, s_net_load, l_net_items_current->chain_net);
dap_timerfd_t *l_load_notify_timer = dap_timerfd_start(5000, (dap_timerfd_callback_t)s_net_disk_load_notify_callback, NULL);
for (dap_chain_net_t *net = s_nets_by_name; net; net = net->hh.next)
dap_proc_thread_callback_add(NULL, s_net_load, net);
while (s_net_loading_count)
pthread_cond_wait(&s_net_cond, &s_net_cond_lock);
pthread_mutex_unlock(&s_net_cond_lock);
dap_timerfd_delete_mt(l_load_notify_timer->worker, l_load_notify_timer->esocket_uuid);
}
dap_string_t* dap_cli_list_net()
{
dap_chain_net_item_t * l_net_item, *l_net_item_tmp;
dap_string_t *l_string_ret = dap_string_new("");
dap_chain_net_t * l_net = NULL;
int l_net_i = 0;
dap_string_append(l_string_ret,"Available networks and chains:\n");
HASH_ITER(hh, s_net_items, l_net_item, l_net_item_tmp){
l_net = l_net_item->chain_net;
dap_string_append_printf(l_string_ret, "\t%s:\n", l_net_item->name);
l_net_i++;
dap_chain_t * l_chain = l_net->pub.chains;
unsigned l_net_i = 0;
dap_string_append(l_string_ret, "Available networks and chains:\n");
for (dap_chain_net_t *net = s_nets_by_name; net; net = net->hh.next) {
dap_string_append_printf(l_string_ret, "\t%s:\n", net->pub.name);
++l_net_i;
dap_chain_t *l_chain = net->pub.chains;
while (l_chain) {
dap_string_append_printf(l_string_ret, "\t\t%s\n", l_chain->name );
dap_string_append_printf( l_string_ret, "\t\t%s\n", l_chain->name );
l_chain = l_chain->next;
}
}
......@@ -963,13 +1028,11 @@ static int s_cli_net(int argc, char **argv, void **reply)
json_object_object_add(l_jobj_return, "net", l_jobj_net_name);
json_object_object_add(l_jobj_return, "chains", l_jobj_chains);
}else{
dap_chain_net_item_t * l_net_item, *l_net_item_tmp;
json_object *l_jobj_networks = json_object_new_array();
HASH_ITER(hh, s_net_items, l_net_item, l_net_item_tmp){
for (dap_chain_net_t *l_net = s_nets_by_name; l_net; l_net = l_net->hh.next) {
json_object *l_jobj_network = json_object_new_object();
json_object *l_jobj_chains = json_object_new_array();
l_net = l_net_item->chain_net;
json_object *l_jobj_network_name = json_object_new_string(l_net_item->name);
json_object *l_jobj_network_name = json_object_new_string(l_net->pub.name);
if (!l_jobj_network || !l_jobj_chains || !l_jobj_network_name) {
json_object_put(l_jobj_return);
json_object_put(l_jobj_network);
......@@ -1041,9 +1104,8 @@ static int s_cli_net(int argc, char **argv, void **reply)
json_object *l_jobj_networks = json_object_new_array();
// show list of nets
dap_chain_net_item_t * l_net_item, *l_net_item_tmp;
HASH_ITER(hh, s_net_items, l_net_item, l_net_item_tmp){
json_object *l_jobj_network_name = json_object_new_string(l_net_item->name);
for (dap_chain_net_t *l_net = s_nets_by_name; l_net; l_net = l_net->hh.next) {
json_object *l_jobj_network_name = json_object_new_string(l_net->pub.name);
json_object_array_add(l_jobj_networks, l_jobj_network_name);
}
json_object_object_add(l_jobj_return, "networks", l_jobj_networks);
......@@ -1662,11 +1724,11 @@ void dap_chain_net_deinit()
{
dap_link_manager_deinit();
dap_chain_net_balancer_deinit();
dap_chain_net_item_t *l_current_item, *l_tmp;
HASH_ITER(hh, s_net_ids, l_current_item, l_tmp)
HASH_DELETE(hh2, s_net_ids, l_current_item);
HASH_ITER(hh, s_net_items, l_current_item, l_tmp) {
dap_chain_net_delete(l_current_item->chain_net);
dap_chain_net_t *l_net, *l_tmp;
HASH_ITER(hh2, s_nets_by_id, l_net, l_tmp) {
HASH_DEL(s_nets_by_name, l_net);
HASH_DELETE(hh2, s_nets_by_id, l_net);
dap_chain_net_delete(l_net);
}
dap_http_ban_list_client_deinit();
}
......@@ -1692,15 +1754,8 @@ void dap_chain_net_delete(dap_chain_net_t *a_net)
dap_global_db_cluster_delete(PVT(a_net)->nodes_states);
dap_global_db_cluster_delete(PVT(a_net)->common_orders);
dap_chain_net_item_t *l_net_item = NULL;
HASH_FIND(hh, s_net_items, a_net->pub.name, strlen(a_net->pub.name), l_net_item);
if (l_net_item) {
HASH_DEL(s_net_items, l_net_item);
HASH_DELETE(hh2, s_net_ids, l_net_item);
DAP_DELETE(l_net_item);
}
DAP_DEL_Z(PVT(a_net)->authorized_nodes_addrs);
DAP_DEL_Z(PVT(a_net)->node_info);
DAP_DELETE(PVT(a_net)->authorized_nodes_addrs);
DAP_DELETE(PVT(a_net)->node_info);
if (a_net->pub.ledger) {
dap_ledger_purge(a_net->pub.ledger, true);
dap_ledger_handle_free(a_net->pub.ledger);
......@@ -1711,22 +1766,15 @@ void dap_chain_net_delete(dap_chain_net_t *a_net)
#ifdef DAP_LEDGER_TEST
int dap_chain_net_test_init()
{
dap_chain_net_id_t l_iddn = {0};
sscanf("0xFA0", "0x%16"DAP_UINT64_FORMAT_x, &l_iddn.uint64);
dap_chain_net_t *l_net = s_net_new(&l_iddn, "Snet", "TestCoin", "root");
// l_net->pub.id.uint64 = l_iddn.uint64;
// l_net->pub.native_ticker = "TestCoin";
// l_net->pub.name = "Snet";
dap_chain_net_item_t *l_net_item = DAP_NEW_Z(dap_chain_net_item_t);
dap_strncpy(l_net_item->name, "Snet", DAP_CHAIN_NET_NAME_MAX);
l_net_item->chain_net = l_net;
l_net_item->net_id.uint64 = l_net->pub.id.uint64;
HASH_ADD(hh2, s_net_ids, net_id, sizeof(l_net_item->net_id), l_net_item);
dap_chain_net_t *l_net = DAP_NEW_Z_SIZE( dap_chain_net_t, sizeof(dap_chain_net_t) + sizeof(dap_chain_net_pvt_t) );
PVT(l_net)->node_info = DAP_NEW_Z_SIZE(dap_chain_net_t, sizeof(dap_chain_node_info_t) + DAP_HOSTADDR_STRLEN + 1 );
l_net->pub.id.uint64 = 0xFA0;
strcpy(l_net->pub.name, "Snet");
l_net->pub.gdb_groups_prefix = (const char*)l_net->pub.name;
l_net->pub.native_ticker = "TestCoin";
PVT(l_net)->node_role.enums = NODE_ROLE_ROOT;
HASH_ADD(hh2, s_nets_by_id, pub.id, sizeof(dap_chain_net_id_t), l_net);
HASH_ADD_STR(s_nets_by_name, pub.name, l_net);
return 0;
}
#endif
......@@ -1743,76 +1791,36 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
{
char *l_cfg_path = dap_strdup_printf("network/%s", a_net_name);
dap_config_t *l_cfg = dap_config_open(l_cfg_path);
if (!l_cfg) {
log_it(L_ERROR,"Can't open default network config %s", l_cfg_path);
DAP_DEL_Z(l_cfg_path);
return -1;
}
DAP_DELETE(l_cfg_path);
if ( !l_cfg )
return log_it(L_ERROR,"Can't open default network config %s", l_cfg_path), -1;
const char *l_net_name_str = dap_config_get_item_str(l_cfg , "general", "name");
const char *l_net_id_str = dap_config_get_item_str(l_cfg , "general", "id");
dap_chain_net_id_t l_net_id;
if(!l_net_name_str || !l_net_id_str || dap_chain_net_id_parse(l_net_id_str, &l_net_id)) {
log_it(L_ERROR,"Can't create l_net, can't read name or ID config");
return -1;
}
dap_chain_net_item_t *l_net_item_finded = NULL;
HASH_FIND_STR(s_net_items, l_net_name_str, l_net_item_finded);
if (!l_net_item_finded)
HASH_FIND(hh2, s_net_ids, &l_net_id, sizeof(l_net_id), l_net_item_finded);
if (l_net_item_finded) {
log_it(L_ERROR,"Can't create net %s ID %"DAP_UINT64_FORMAT_U", existed net %s ID %"DAP_UINT64_FORMAT_U" has the same name or ID.\n"\
"Please, fix your configs and restart node",
l_net_name_str, l_net_id.uint64, l_net_item_finded->name,
l_net_item_finded->net_id.uint64);
dap_config_close(l_cfg);
return -2;
}
dap_chain_net_t *l_net = s_net_new(
&l_net_id,
dap_config_get_item_str(l_cfg , "general" , "name" ),
dap_config_get_item_str(l_cfg , "general" , "native_ticker"),
dap_config_get_item_str(l_cfg , "general" , "node-role" )
);
if(!l_net) {
log_it(L_ERROR,"Can't create l_net");
dap_config_close(l_cfg);
return -1;
}
dap_chain_net_t *l_net = s_net_new(a_net_name, l_cfg);
if ( !l_net )
return log_it(L_ERROR,"Can't create net \"%s\"", a_net_name), dap_config_close(l_cfg), -1;
l_net->pub.gdb_groups_prefix = dap_strdup(
dap_config_get_item_str_default(l_cfg, "general", "gdb_groups_prefix",
dap_config_get_item_str(l_cfg, "general", "name")));
dap_chain_net_pvt_t *l_net_pvt = PVT(l_net);
l_net_pvt->load_mode = true;
l_net_pvt->acl_idx = a_acl_idx;
// Bridged netwoks allowed to send transactions to
// Transaction can be sent to bridged networks
uint16_t l_net_ids_count = 0;
const char **l_bridged_net_ids = dap_config_get_array_str(l_cfg, "general", "bridged_network_ids", &l_net_ids_count);
for (uint16_t i = 0; i < l_net_ids_count; i++) {
dap_chain_net_id_t l_id;
if (dap_chain_net_id_parse(l_bridged_net_ids[i], &l_id) != 0)
continue;
l_net->pub.bridged_networks = dap_list_append(l_net->pub.bridged_networks, DAP_DUP(&l_id));
}
// Add network to the list
dap_chain_net_item_t *l_net_item = DAP_NEW_Z(dap_chain_net_item_t);
if (!l_net_item) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -4;
if (l_net_ids_count) {
l_net->pub.bridged_networks = DAP_NEW_Z_COUNT(dap_chain_net_id_t, l_net_ids_count);
unsigned i, j;
for (i = 0, j = 0; i < l_net_ids_count; ++i) {
if (dap_chain_net_id_parse(l_bridged_net_ids[i], &l_net->pub.bridged_networks[j]) != 0) {
log_it(L_ERROR, "Can't add invalid net id \"%s\" to bridged net list of \"%s\"",
l_bridged_net_ids[i], a_net_name);
continue;
}
++j;
}
l_net->pub.bridged_networks = j && j < i
? DAP_REALLOC_COUNT(l_net->pub.bridged_networks, j)
: ( DAP_DELETE(l_net->pub.bridged_networks), NULL );
l_net->pub.bridged_networks_count = j;
}
dap_strncpy(l_net_item->name, dap_config_get_item_str(l_cfg, "general", "name"), DAP_CHAIN_NET_NAME_MAX);
l_net_item->chain_net = l_net;
l_net_item->net_id.uint64 = l_net->pub.id.uint64;
HASH_ADD_STR(s_net_items, name, l_net_item);
HASH_ADD(hh2, s_net_ids, net_id, sizeof(l_net_item->net_id), l_net_item);
const char **l_permanent_nodes_addrs = dap_config_get_array_str(l_cfg, "general", "permanent_nodes_addrs", &l_net_pvt->permanent_links_count);
if (l_net_pvt->permanent_links_count) {
......@@ -1842,27 +1850,25 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
uint16_t l_permalink_hosts_count = 0, i, e;
const char **l_permanent_links_hosts = dap_config_get_array_str(l_cfg, "general", "permanent_nodes_hosts", &l_permalink_hosts_count);
for (i = 0, e = 0; i < dap_min(l_permalink_hosts_count, l_net_pvt->permanent_links_count); ++i) {
char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' }; uint16_t l_port = 0;
struct sockaddr_storage l_saddr;
if ( dap_net_parse_config_address(l_permanent_links_hosts[i], l_host, &l_port, NULL, NULL) < 0
|| dap_net_resolve_host(l_host, dap_itoa(l_port), false, &l_saddr, NULL) < 0 )
{
struct request_link_info *l_tmp = s_net_resolve_host( l_permanent_links_hosts[i] );
if ( !l_tmp ) {
log_it(L_ERROR, "Incorrect address \"%s\", fix \"%s\" network config"
"or check internet connection and restart node",
a_net_name, l_permanent_links_hosts[i]);
++e;
continue;
}
l_net_pvt->permanent_links[i]->uplink_port = l_port;
dap_strncpy(l_net_pvt->permanent_links[i]->uplink_addr, l_host, DAP_HOSTADDR_STRLEN);
l_net_pvt->permanent_links[i]->uplink_port = l_tmp->port;
dap_strncpy(l_net_pvt->permanent_links[i]->uplink_addr, l_tmp->addr, DAP_HOSTADDR_STRLEN);
DAP_DELETE(l_tmp);
}
if ( i && (e == i) ) {
log_it(L_ERROR, "%d / %d permanent links are invalid or can't be accessed, fix \"%s\""
"network config or check internet connection and restart node",
e, i, a_net_name);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -16;
//dap_chain_net_delete(l_net);
//dap_config_close(l_cfg);
//return -16;
}
const char **l_authorized_nodes_addrs = dap_config_get_array_str(l_cfg, "general", "authorized_nodes_addrs", &l_net_pvt->authorized_nodes_count);
......@@ -1885,41 +1891,28 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
l_seed_nodes_hosts = dap_config_get_array_str(l_cfg, "general", "bootstrap_hosts", &l_net_pvt->seed_nodes_count);
if (!l_net_pvt->seed_nodes_count)
log_it(L_WARNING, "Can't read seed nodes addresses, work with local balancer only");
else if (!(l_net_pvt->seed_nodes_info = DAP_NEW_Z_COUNT(struct request_link_info *, l_net_pvt->seed_nodes_count))) {
else if (!( l_net_pvt->seed_nodes_info = DAP_NEW_Z_COUNT(struct request_link_info*, l_net_pvt->seed_nodes_count) )) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -4;
}
for (i = 0, e = 0; i < l_net_pvt->seed_nodes_count; ++i) {
char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' }; uint16_t l_port = 0;
struct sockaddr_storage l_saddr;
if ( dap_net_parse_config_address(l_seed_nodes_hosts[i], l_host, &l_port, NULL, NULL) < 0
|| dap_net_resolve_host(l_host, dap_itoa(l_port), false, &l_saddr, NULL) < 0)
{
if (!( l_net_pvt->seed_nodes_info[i] = s_net_resolve_host(l_seed_nodes_hosts[i]) )) {
log_it(L_ERROR, "Incorrect address \"%s\", fix \"%s\" network config"
"or check internet connection and restart node",
a_net_name, l_seed_nodes_hosts[i]);
++e;
continue;
}
l_net_pvt->seed_nodes_info[i] = DAP_NEW_Z(struct request_link_info);
if (!l_net_pvt->seed_nodes_info[i]) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -4;
}
l_net_pvt->seed_nodes_info[i]->port = l_port;
dap_strncpy(l_net_pvt->seed_nodes_info[i]->addr, l_host, DAP_HOSTADDR_STRLEN);
}
if ( i && (e == i) ) {
log_it(L_ERROR, "%d / %d seed links are invalid or can't be accessed, fix \"%s\""
"network config or check internet connection and restart node",
e, i, a_net_name);
dap_chain_net_delete(l_net);
dap_config_close(l_cfg);
return -16;
//dap_chain_net_delete(l_net);
//dap_config_close(l_cfg);
//return -16;
}
/* *** Chains init by configs *** */
......@@ -2045,7 +2038,6 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
l_net->pub.ledger = dap_ledger_create(l_net, l_ledger_flags);
// Decrees initializing
dap_chain_net_decree_init(l_net);
l_net->pub.config = l_cfg;
return 0;
}
......@@ -2217,7 +2209,7 @@ bool s_net_load(void *a_arg)
DAP_CLUSTER_TYPE_EMBEDDED);
DAP_DELETE(l_gdb_groups_mask);
// Nodes and its aliases cluster
l_net->pub.gdb_nodes = dap_strdup_printf("%s.nodes.list",l_net->pub.gdb_groups_prefix);
snprintf(l_net->pub.gdb_nodes, sizeof(l_net->pub.gdb_nodes), "%s.%s", l_net->pub.gdb_groups_prefix, s_gdb_nodes_postfix);
l_net_pvt->nodes_cluster = dap_global_db_cluster_add(dap_global_db_instance_get_default(),
l_net->pub.name, dap_guuid_compose(l_net->pub.id.uint64, 0),
l_net->pub.gdb_nodes, 0, true,
......@@ -2373,22 +2365,15 @@ bool dap_chain_net_remove_validator_from_clusters(dap_chain_t *a_chain, dap_stre
}
size_t dap_chain_net_count() {
return HASH_COUNT(s_net_items);
return HASH_COUNT(s_nets_by_name);
}
dap_chain_net_t *dap_chain_net_iter_start() {
dap_return_val_if_pass(!s_net_items, NULL);
return s_net_items->chain_net;
return s_nets_by_name;
}
dap_chain_net_t *dap_chain_net_iter_next(dap_chain_net_t *a_it) {
if (!a_it)
return NULL;
dap_chain_net_item_t *l_net_sought = NULL;
HASH_FIND_STR(s_net_items, a_it->pub.name, l_net_sought);
return l_net_sought && l_net_sought->hh.next
? ((dap_chain_net_item_t*)l_net_sought->hh.next)->chain_net
: NULL;
return a_it ? a_it->hh.next : NULL;
}
/**
......@@ -2398,10 +2383,10 @@ dap_chain_net_t *dap_chain_net_iter_next(dap_chain_net_t *a_it) {
*/
dap_chain_net_t *dap_chain_net_by_name(const char *a_name)
{
dap_chain_net_item_t *l_net_item = NULL;
dap_chain_net_t *l_net = NULL;
if (a_name)
HASH_FIND(hh, s_net_items, a_name, strlen(a_name), l_net_item);
return l_net_item ? l_net_item->chain_net : NULL;
HASH_FIND_STR(s_nets_by_name, a_name, l_net);
return l_net;
}
/**
......@@ -2422,9 +2407,9 @@ dap_ledger_t * dap_ledger_by_net_name( const char * a_net_name)
*/
dap_chain_net_t *dap_chain_net_by_id(dap_chain_net_id_t a_id)
{
dap_chain_net_item_t *l_net_item = NULL;
HASH_FIND(hh2, s_net_ids, &a_id, sizeof(a_id), l_net_item);
return l_net_item ? l_net_item->chain_net : NULL;
dap_chain_net_t *l_net = NULL;
HASH_FIND(hh2, s_nets_by_id, &a_id, sizeof(a_id), l_net);
return l_net;
}
/**
......@@ -2715,14 +2700,13 @@ static bool s_net_check_acl(dap_chain_net_t *a_net, dap_chain_hash_fast_t *a_pke
*/
static uint8_t *s_net_set_acl(dap_chain_hash_fast_t *a_pkey_hash)
{
if (!HASH_COUNT(s_net_items))
uint16_t l_cnt = HASH_COUNT(s_nets_by_name);
if ( !l_cnt )
return NULL;
uint8_t *l_ret = DAP_NEW_Z_SIZE(uint8_t, HASH_COUNT(s_net_items));
uint8_t *l_ret = DAP_NEW_Z_COUNT(uint8_t, l_cnt);
unsigned i = 0;
dap_chain_net_item_t *l_net_cur = NULL, *l_net_tmp = NULL;
HASH_ITER(hh, s_net_items, l_net_cur, l_net_tmp) {
l_ret[i++] = s_net_check_acl(l_net_cur->chain_net, a_pkey_hash);
}
for (dap_chain_net_t *l_net = s_nets_by_name; l_net; l_net = l_net->hh.next)
l_ret[i++] = s_net_check_acl(l_net, a_pkey_hash);
return l_ret;
}
......@@ -2801,7 +2785,7 @@ dap_list_t* dap_chain_datum_list(dap_chain_net_t *a_net, dap_chain_t *a_chain, d
* @param a_datum_size
* @return
*/
int dap_chain_datum_add(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t a_datum_size, dap_hash_fast_t *a_datum_hash)
int dap_chain_datum_add(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t a_datum_size, dap_hash_fast_t *a_datum_hash, void *a_datum_index_data)
{
size_t l_datum_data_size = a_datum->header.data_size;
if (a_datum_size < l_datum_data_size + sizeof(a_datum->header)) {
......@@ -2843,8 +2827,8 @@ int dap_chain_datum_add(dap_chain_t *a_chain, dap_chain_datum_t *a_datum, size_t
if (l_tx_size != l_datum_data_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);
}
return dap_ledger_tx_load(l_ledger, l_tx, a_datum_hash, (dap_ledger_datum_iter_data_t*)a_datum_index_data);
}
case DAP_CHAIN_DATUM_CA:
return dap_cert_chain_file_save(a_datum, a_chain->net_name);
......@@ -2955,8 +2939,8 @@ uint256_t dap_chain_net_get_reward(dap_chain_net_t *a_net, uint64_t a_block_num)
void dap_chain_net_announce_addr_all()
{
for (dap_chain_net_item_t *it = s_net_items; it; it = it->hh.next)
dap_chain_net_announce_addr(it->chain_net);
for (dap_chain_net_t *net = s_nets_by_name; net; net = net->hh.next)
dap_chain_net_announce_addr(net);
}
void dap_chain_net_announce_addr(dap_chain_net_t *a_net)
......@@ -2964,11 +2948,12 @@ void dap_chain_net_announce_addr(dap_chain_net_t *a_net)
dap_return_if_fail(a_net);
dap_chain_net_pvt_t *l_net_pvt = PVT(a_net);
if ( l_net_pvt->node_info->ext_port ) {
dap_chain_net_node_list_request(a_net, l_net_pvt->node_info->ext_port, false, 'a');
log_it(L_INFO, "Announce our node address "NODE_ADDR_FP_STR" [ %s : %u ] in net %s",
NODE_ADDR_FP_ARGS_S(g_node_addr),
l_net_pvt->node_info->ext_host,
l_net_pvt->node_info->ext_port, a_net->pub.name);
dap_chain_net_node_list_request(a_net, l_net_pvt->node_info->ext_port, true, 'a');
}
}
......@@ -3018,19 +3003,15 @@ static int s_net_try_online(dap_chain_net_t *a_net)
void dap_chain_net_try_online_all() {
int32_t l_ret = 0;
if(!HASH_COUNT(s_net_items)){
log_it(L_ERROR, "Can't find any nets");
return;
}
if (!dap_config_get_item_bool_default(g_config ,"general", "auto_online", false)) {
log_it(L_DEBUG, "Auto online is off in config");
return;
}
dap_chain_net_item_t *l_net_items_current = NULL, *l_net_items_tmp = NULL;
HASH_ITER(hh, s_net_items, l_net_items_current, l_net_items_tmp) {
if( (l_ret = s_net_try_online(l_net_items_current->chain_net)) ) {
log_it(L_ERROR, "Can't try online state for net %s. Finished with (%d) error code.", l_net_items_current->name, l_ret);
}
if( !HASH_COUNT(s_nets_by_name) )
return log_it(L_ERROR, "Can't find any nets");
if ( !dap_config_get_item_bool_default(g_config ,"general", "auto_online", false) )
return log_it(L_DEBUG, "Auto online is off in config");
for (dap_chain_net_t *net = s_nets_by_name; net; net = net->hh.next) {
if (( l_ret = s_net_try_online(net) ))
log_it(L_ERROR, "Can't try online state for net %s. Finished with (%d) error code.", net, l_ret);
}
}
......@@ -3083,9 +3064,10 @@ static void s_ch_in_pkt_callback(dap_stream_ch_t *a_ch, uint8_t a_type, const vo
if (!dap_hash_fast_compare(&l_miss_info->missed_hash, &l_net_pvt->sync_context.requested_atom_hash)) {
char l_missed_hash_str[DAP_HASH_FAST_STR_SIZE];
dap_hash_fast_to_str(&l_miss_info->missed_hash, l_missed_hash_str, DAP_HASH_FAST_STR_SIZE);
log_it(L_WARNING, "Get irrelevant chain sync MISSED packet with missed hash %s, but requested hash is %s",
log_it(L_WARNING, "Get irrelevant chain sync MISSED packet with missed hash %s, but requested hash is %s. Net %s chain %s",
l_missed_hash_str,
dap_hash_fast_to_str_static(&l_net_pvt->sync_context.requested_atom_hash));
dap_hash_fast_to_str_static(&l_net_pvt->sync_context.requested_atom_hash),
l_net->pub.name, l_net_pvt->sync_context.cur_chain->name);
dap_stream_ch_write_error_unsafe(a_ch, l_net->pub.id,
l_net_pvt->sync_context.cur_chain->id,
l_net_pvt->sync_context.cur_cell
......@@ -3152,10 +3134,11 @@ static void s_ch_in_pkt_callback(dap_stream_ch_t *a_ch, uint8_t a_type, const vo
static void s_ch_out_pkt_callback(dap_stream_ch_t *a_ch, uint8_t a_type, const void *a_data, size_t a_data_size, void *a_arg)
{
debug_if(s_debug_more, L_DEBUG, "Sent OUT sync packet type %hhu size %zu to addr " NODE_ADDR_FP_STR,
a_type, a_data_size, NODE_ADDR_FP_ARGS_S(a_ch->stream->node));
dap_chain_net_t *l_net = a_arg;
dap_chain_net_pvt_t *l_net_pvt = PVT(l_net);
if (!l_net_pvt->sync_context.cur_chain)
return;
switch (a_type) {
case DAP_CHAIN_CH_PKT_TYPE_ERROR:
l_net_pvt->sync_context.cur_chain->state = CHAIN_SYNC_STATE_ERROR;
......@@ -3164,6 +3147,8 @@ static void s_ch_out_pkt_callback(dap_stream_ch_t *a_ch, uint8_t a_type, const v
break;
}
l_net_pvt->sync_context.stage_last_activity = dap_time_now();
debug_if(s_debug_more, L_DEBUG, "Sent OUT sync packet type %hhu size %zu to addr " NODE_ADDR_FP_STR,
a_type, a_data_size, NODE_ADDR_FP_ARGS_S(a_ch->stream->node));
}
......@@ -3271,6 +3256,12 @@ static void s_sync_timer_callback(void *a_arg)
l_net_pvt->sync_context.cur_chain->state = CHAIN_SYNC_STATE_SYNCED;
return;
}
// if sync more than 3 mins after online state, change state to SYNC
if (l_net_pvt->state == NET_STATE_ONLINE && l_net_pvt->sync_context.state == CHAIN_SYNC_STATE_WAITING &&
dap_time_now() - l_net_pvt->sync_context.stage_last_activity > l_net_pvt->sync_context.sync_idle_time ) {
l_net_pvt->state = NET_STATE_SYNC_CHAINS;
s_net_states_proc(l_net);
}
l_net_pvt->sync_context.cur_cell = l_net_pvt->sync_context.cur_chain->cells;
l_net_pvt->sync_context.cur_chain->state = CHAIN_SYNC_STATE_WAITING;
......@@ -3385,6 +3376,20 @@ 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 ( !*l_permalink_info->uplink_addr ) {
// Unresolved before? Let's try again
const char **l_permanent_nodes_addrs = dap_config_get_array_str(a_net->pub.config, "general", "permanent_nodes_addrs", NULL);
struct request_link_info *l_tmp = s_net_resolve_host(l_permanent_nodes_addrs[i]);
if (l_tmp) {
l_permalink_info->uplink_port = l_tmp->port;
dap_strncpy(l_permalink_info->uplink_addr, l_tmp->addr, DAP_HOSTADDR_STRLEN);
DAP_DELETE(l_tmp);
} else {
log_it(L_ERROR, "Can't resolve permanent link address %s for net %s, possibly an internet connection issue",
l_permanent_nodes_addrs[i], a_net->pub.name);
continue;
}
}
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;
......@@ -3406,4 +3411,4 @@ DAP_INLINE dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t
return PVT(a_net)->state_target;
}
/*------------------------------------State machine block end---------------------------------*/
/*------------------------------------State machine block end---------------------------------*/
\ No newline at end of file
modules/net/dap_chain_net_balancer.c
View file @ 63c82b97
......@@ -46,7 +46,6 @@ typedef struct dap_balancer_request_info {
static_assert(sizeof(dap_chain_net_links_t) + sizeof(dap_chain_node_info_old_t) < DAP_BALANCER_MAX_REPLY_SIZE, "DAP_BALANCER_MAX_REPLY_SIZE cannot accommodate information minimum about 1 link");
static const size_t s_max_links_response_count = (DAP_BALANCER_MAX_REPLY_SIZE - sizeof(dap_chain_net_links_t)) / sizeof(dap_chain_node_info_old_t);
static const dap_time_t s_request_period = 5; // sec
static dap_balancer_request_info_t* s_request_info_items = NULL;
/**
......@@ -78,22 +77,30 @@ static dap_chain_net_links_t *s_get_ignored_node_addrs(dap_chain_net_t *a_net, s
size_t
l_size = 0,
l_uplinks_count = 0,
l_downlinks_count = 0,
l_links_count = 0,
l_low_availability_count = 0;
const dap_stream_node_addr_t
*l_curr_addr = &dap_chain_net_get_my_node_info(a_net)->address,
*l_uplinks = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, NULL, true),
*l_links = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, &l_downlinks_count, false),
*l_low_availability = dap_link_manager_get_ignored_addrs(&l_low_availability_count, a_net->pub.id.uint64);
if(!l_curr_addr->uint64 && !l_uplinks && !l_low_availability) {
l_links_count = l_uplinks_count + l_downlinks_count;
if(!l_curr_addr->uint64 && !l_links && !l_low_availability) {
log_it(L_WARNING, "Error forming ignore list in net %s, please check, should be minimum self addr", a_net->pub.name);
return NULL;
}
l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_links_count + l_low_availability_count + 1);
// memory alloc
dap_chain_net_links_t *l_ret = NULL;
DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, l_links, l_low_availability);
l_ret->count_node = l_links_count + l_low_availability_count + 1;
if (dap_log_level_get() <= L_DEBUG ) {
char *l_ignored_str = NULL;
DAP_NEW_Z_SIZE_RET_VAL(l_ignored_str, char, 50 * (l_uplinks_count + l_low_availability_count + 1) + 200 + strlen(a_net->pub.name), NULL, l_uplinks, l_low_availability);
sprintf(l_ignored_str + strlen(l_ignored_str), "Second %zu nodes will be ignored in balancer links preparing in net %s:\n\tSelf:\n\t\t"NODE_ADDR_FP_STR"\n", l_uplinks_count + l_low_availability_count + 1, a_net->pub.name, NODE_ADDR_FP_ARGS(l_curr_addr));
sprintf(l_ignored_str + strlen(l_ignored_str), "\tUplinks (%zu):\n", l_uplinks_count);
for (size_t i = 0; i < l_uplinks_count; ++i) {
sprintf(l_ignored_str + strlen(l_ignored_str), "\t\t"NODE_ADDR_FP_STR"\n", NODE_ADDR_FP_ARGS(l_uplinks + i));
DAP_NEW_Z_SIZE_RET_VAL(l_ignored_str, char, 50 * (l_ret->count_node) + 200 + strlen(a_net->pub.name), NULL, l_links, l_low_availability);
sprintf(l_ignored_str + strlen(l_ignored_str), "Second %zu nodes will be ignored in balancer links preparing in net %s:\n\tSelf:\n\t\t"NODE_ADDR_FP_STR"\n", l_ret->count_node, a_net->pub.name, NODE_ADDR_FP_ARGS(l_curr_addr));
sprintf(l_ignored_str + strlen(l_ignored_str), "\tActive links (%zu):\n", l_links_count);
for (size_t i = 0; i < l_links_count; ++i) {
sprintf(l_ignored_str + strlen(l_ignored_str), "\t\t"NODE_ADDR_FP_STR"\n", NODE_ADDR_FP_ARGS(l_links + i));
}
sprintf(l_ignored_str + strlen(l_ignored_str), "\tCooling (%zu):\n", l_low_availability_count);
for (size_t i = 0; i < l_low_availability_count; ++i) {
......@@ -102,20 +109,15 @@ static dap_chain_net_links_t *s_get_ignored_node_addrs(dap_chain_net_t *a_net, s
log_it(L_DEBUG, "%s", l_ignored_str);
DAP_DELETE(l_ignored_str);
}
l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_uplinks_count + l_low_availability_count + 1);
// memory alloc
dap_chain_net_links_t *l_ret = NULL;
DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, l_uplinks, l_low_availability);
// func work
memcpy(l_ret->nodes_info, l_curr_addr, sizeof(dap_stream_node_addr_t));
if(l_uplinks)
memcpy(l_ret->nodes_info + sizeof(dap_stream_node_addr_t), l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
if(l_links)
memcpy(l_ret->nodes_info + sizeof(dap_stream_node_addr_t), l_links, l_links_count * sizeof(dap_stream_node_addr_t));
if(l_low_availability)
memcpy(l_ret->nodes_info + (l_uplinks_count + 1) * sizeof(dap_stream_node_addr_t), l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
l_ret->count_node = l_uplinks_count + l_low_availability_count + 1;
memcpy(l_ret->nodes_info + (l_links_count + 1) * sizeof(dap_stream_node_addr_t), l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
if (a_size)
*a_size = l_size;
DAP_DEL_MULTY(l_uplinks, l_low_availability);
DAP_DEL_MULTY(l_links, l_low_availability);
return l_ret;
}
......
modules/net/dap_chain_node.c
View file @ 63c82b97
......@@ -47,8 +47,12 @@
#include "dap_chain_ledger.h"
#define LOG_TAG "dap_chain_node"
#define DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION 2
typedef struct dap_chain_node_net_states_info {
uint16_t version_info;
char version_node[16];
dap_chain_node_role_t role;
dap_chain_node_addr_t address;
uint64_t events_count;
uint64_t atoms_count;
......@@ -62,6 +66,8 @@ static const uint64_t s_cmp_delta_event = 0;
static const uint64_t s_cmp_delta_atom = 10;
static const uint64_t s_timer_update_states_info = 10 /*sec*/ * 1000;
static const char s_states_group[] = ".nodes.states";
// only add in version up, not change!!!
static const uint16_t s_states_version_size[DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION] = { 32, 54 };
/**
* @brief get states info about current
......@@ -69,6 +75,10 @@ static const char s_states_group[] = ".nodes.states";
*/
static void s_update_node_states_info(UNUSED_ARG void *a_arg)
{
#ifndef DAP_VERSION
#pragma message "[!WRN!] DAP_VERSION IS NOT DEFINED. Manual override engaged."
#define DAP_VERSION "0.9-15"
#endif
for (dap_chain_net_t *l_net = dap_chain_net_iter_start(); l_net; l_net = dap_chain_net_iter_next(l_net)) {
if(dap_chain_net_get_state(l_net) != NET_STATE_OFFLINE) {
size_t
......@@ -76,19 +86,22 @@ static void s_update_node_states_info(UNUSED_ARG void *a_arg)
l_downlinks_count = 0,
l_info_size = 0;
// memory alloc first
dap_stream_node_addr_t *l_linked_node_addrs = dap_link_manager_get_net_links_addrs(l_net->pub.id.uint64, &l_uplinks_count, &l_downlinks_count, false);
dap_stream_node_addr_t *l_linked_node_addrs = dap_link_manager_get_net_links_addrs(l_net->pub.id.uint64, &l_uplinks_count, &l_downlinks_count, true);
dap_chain_node_net_states_info_t *l_info = NULL;
l_info_size = sizeof(dap_chain_node_net_states_info_t) + (l_uplinks_count + l_downlinks_count) * sizeof(dap_chain_node_addr_t);
DAP_NEW_Z_SIZE_RET(l_info, dap_chain_node_net_states_info_t, l_info_size, l_linked_node_addrs);
// func work
// data preparing
l_info->version_info = DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION;
dap_strncpy(l_info->version_node, DAP_VERSION, sizeof(l_info->version_node) - 1);
l_info->role = dap_chain_net_get_role(l_net);
l_info->address.uint64 = g_node_addr.uint64;
l_info->uplinks_count = l_uplinks_count;
l_info->downlinks_count = l_downlinks_count;
dap_chain_t *l_chain = dap_chain_find_by_id(l_net->pub.id, (dap_chain_id_t){ .uint64 = 0 }); // zerochain
l_info->events_count = (l_chain && l_chain->callback_count_atom) ? l_chain->callback_count_atom(l_chain) : 0;
l_chain =dap_chain_find_by_id(l_net->pub.id, (dap_chain_id_t){ .uint64 = 1 }); // mainchain
l_chain = l_chain ? l_chain->next : NULL; // mainchain
l_info->atoms_count = (l_chain && l_chain->callback_count_atom) ? l_chain->callback_count_atom(l_chain) : 0;
memcpy(l_info->links_addrs, l_linked_node_addrs, (l_info->uplinks_count + l_info->downlinks_count) * sizeof(dap_chain_node_addr_t));
......@@ -110,16 +123,18 @@ static void s_states_info_to_str(dap_chain_net_t *a_net, const char *a_node_addr
size_t l_data_size = 0;
char *l_gdb_group = dap_strdup_printf("%s%s", a_net->pub.gdb_groups_prefix, s_states_group);
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, a_node_addr_str, &l_data_size, NULL, &l_timestamp);
if (!l_store_obj || l_data_size != sizeof(dap_chain_node_net_states_info_t) + (l_store_obj->uplinks_count + l_store_obj->downlinks_count) * sizeof(dap_chain_node_addr_t)) {
log_it(L_ERROR, "Can't find state about %s node", a_node_addr_str);
if (!l_store_obj || l_store_obj->version_info != DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION ||
l_data_size != s_states_version_size[DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION - 1] + (l_store_obj->uplinks_count + l_store_obj->downlinks_count) * sizeof(dap_chain_node_addr_t))
{
log_it(L_ERROR, "Can't find state about %s node in net %s", a_node_addr_str, a_net->pub.name);
DAP_DELETE(l_gdb_group);
return;
}
char l_ts[80] = { '\0' };
dap_nanotime_to_str_rfc822(l_ts, sizeof(l_ts), l_timestamp);
dap_string_append_printf(l_info_str,
"Record timestamp: %s\nNode addr: %s\nNet: %s\nEvents count: %"DAP_UINT64_FORMAT_U"\nAtoms count: %"DAP_UINT64_FORMAT_U"\nUplinks count: %u\nDownlinks count: %u\n",
l_ts, a_node_addr_str, a_net->pub.name, l_store_obj->events_count, l_store_obj->atoms_count, l_store_obj->uplinks_count, l_store_obj->downlinks_count);
"Record timestamp: %s\nRecord version: %u\nNode version: %s\nNode addr: %s\nNet: %s\nRole: %s\nEvents count: %"DAP_UINT64_FORMAT_U"\nAtoms count: %"DAP_UINT64_FORMAT_U"\nUplinks count: %u\nDownlinks count: %u\n",
l_ts, l_store_obj->version_info, l_store_obj->version_node,a_node_addr_str, a_net->pub.name, dap_chain_node_role_to_str(l_store_obj->role), l_store_obj->events_count, l_store_obj->atoms_count, l_store_obj->uplinks_count, l_store_obj->downlinks_count);
size_t l_max_links = dap_max(l_store_obj->uplinks_count, l_store_obj->downlinks_count);
if(l_max_links) {
dap_string_append_printf(l_info_str,
......@@ -422,6 +437,8 @@ static int s_node_states_info_cmp(dap_list_t *a_first, dap_list_t *a_second)
if(b->events_count > a->events_count && b->events_count - a->events_count > s_cmp_delta_event) return 1;
if(a->atoms_count > b->atoms_count && a->atoms_count - b->atoms_count > s_cmp_delta_atom) return -1;
if(b->atoms_count > a->atoms_count && b->atoms_count - a->atoms_count > s_cmp_delta_atom) return 1;
if(a->role.enums == NODE_ROLE_ROOT) return 1;
if(b->role.enums == NODE_ROLE_ROOT) return -1;
if(a->downlinks_count < b->downlinks_count) return -1;
if(b->downlinks_count < a->downlinks_count) return 1;
return 0;
......@@ -473,10 +490,15 @@ dap_list_t *dap_chain_node_get_states_list_sort(dap_chain_net_t *a_net, dap_chai
if (!l_state_store_obj) {
log_it(L_DEBUG, "Can't find state about %s node, apply low priority", l_objs[i].key);
l_item->downlinks_count = (uint32_t)(-1);
} else if (l_data_size != sizeof(dap_chain_node_net_states_info_t) + (l_state_store_obj->uplinks_count + l_state_store_obj->downlinks_count) * sizeof(dap_chain_node_addr_t)) {
log_it(L_DEBUG, "Wrong %s node state record size, expected %zu, get %zu. Apply low priority", l_objs[i].key, sizeof(dap_chain_node_net_states_info_t) + (l_state_store_obj->uplinks_count + l_state_store_obj->downlinks_count) * sizeof(dap_chain_node_addr_t), l_data_size);
} else if (
l_state_store_obj->version_info != DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION ||
l_data_size != s_states_version_size[DAP_CHAIN_NODE_NET_STATES_INFO_CURRENT_VERSION - 1] + (l_state_store_obj->uplinks_count + l_state_store_obj->downlinks_count) * sizeof(dap_chain_node_addr_t)
) {
log_it(L_DEBUG, "Wrong %s node state record size to state version %u, expected %zu, get %zu. Apply low priority", l_objs[i].key, l_state_store_obj->version_info, sizeof(dap_chain_node_net_states_info_t) + (l_state_store_obj->uplinks_count + l_state_store_obj->downlinks_count) * sizeof(dap_chain_node_addr_t), l_data_size);
l_item->role.enums = NODE_ROLE_ROOT;
l_item->downlinks_count = (uint32_t)(-1);
} else {
l_item->role.enums = l_state_store_obj->role.enums;
l_item->atoms_count = l_state_store_obj->atoms_count;
l_item->events_count = l_state_store_obj->events_count;
l_item->downlinks_count = l_state_store_obj->downlinks_count;
......
modules/net/dap_chain_node_cli.c
View file @ 63c82b97
......@@ -218,9 +218,9 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"\n"
);
dap_cli_server_cmd_add("token_update_sign", com_token_decl_sign, "Token update add sign and new sign",
"token_update_sign -net <net_name> [-chain <chain_name>] -datum <datum_hash> -certs <certs list> -new_certs <certs list>\n"
"\t Sign existent <datum hash> in mempool with <certs list>\n"
dap_cli_server_cmd_add("token_update_sign", com_token_decl_sign, "Token update add sign to datum",
"token_update_sign -net <net_name> [-chain <chain_name>] -datum <datum_hash> -certs <cert_list>\n"
"\t Sign existent <datum hash> in mempool with <certs_list>\n"
);
// Token commands
......@@ -285,8 +285,9 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
// Transaction history
dap_cli_server_cmd_add("tx_history", com_tx_history, "Transaction history (for address or by hash)",
"tx_history {-addr <addr> | -w <wallet_name> | -tx <tx_hash>} [-net <net_name>] [-chain <chain_name>] [-limit] [-offset]\n"
"tx_history -all -net <net_name> [-chain <chain_name>] [-limit] [-offset]\n");
"tx_history {-addr <addr> | -w <wallet_name> | -tx <tx_hash>} [-net <net_name>] [-chain <chain_name>] [-limit] [-offset] [-head]\n"
"tx_history -all -net <net_name> [-chain <chain_name>] [-limit] [-offset] [-head]\n"
"tx_history -count -net <net_name>\n");
// Ledger info
dap_cli_server_cmd_add("ledger", com_ledger, "Ledger information",
......