diff --git a/dap-sdk b/dap-sdk
index 7c637ae9ddb7903f7f78ceb1aa06cf067925b1a7..8113c58299d9e1537edbe03b5f1a2eab72404dd2 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 7c637ae9ddb7903f7f78ceb1aa06cf067925b1a7
+Subproject commit 8113c58299d9e1537edbe03b5f1a2eab72404dd2
diff --git a/modules/chain/tests/dap_chain_ledger_tests.c b/modules/chain/tests/dap_chain_ledger_tests.c
index 9fcb14a39e937e10c9bf57963764bd6acc8c13c1..93dab1a8b94aa56e4759a8d674a4ace854ae6b3f 100644
--- a/modules/chain/tests/dap_chain_ledger_tests.c
+++ b/modules/chain/tests/dap_chain_ledger_tests.c
@@ -721,7 +721,7 @@ void dap_ledger_test_excess_supply(dap_ledger_t *a_ledger, dap_cert_t *a_cert, d
dap_hash_fast(l_femi, dap_chain_datum_emission_get_size((byte_t*)l_femi), &l_femi_hash);
dap_assert_PIF(!dap_ledger_token_emission_add(a_ledger, (byte_t*)l_femi,
dap_chain_datum_emission_get_size((byte_t*)l_femi),
- &l_femi_hash, false), "Added first emission in ledger");
+ &l_femi_hash), "Added first emission in ledger");
//Second emi
dap_chain_datum_token_emission_t *l_semi = dap_chain_datum_emission_create(l_value_second_emi, l_token_ticker, a_addr);
l_semi = dap_chain_datum_emission_add_sign(a_cert->enc_key, l_semi);
@@ -729,7 +729,7 @@ void dap_ledger_test_excess_supply(dap_ledger_t *a_ledger, dap_cert_t *a_cert, d
dap_hash_fast(l_semi, dap_chain_datum_emission_get_size((byte_t*)l_semi), &l_semi_hash);
int res =dap_ledger_token_emission_add(a_ledger, (byte_t*)l_semi,
dap_chain_datum_emission_get_size((byte_t*)l_semi),
- &l_semi_hash, false);
+ &l_semi_hash);
if (!res){
dap_fail("The total supply test failed because the second emission exceeded the total supply.");
} else {
@@ -816,7 +816,7 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
dap_chain_hash_fast_t l_emi_hash = {0};
dap_hash_fast(l_emi, dap_chain_datum_emission_get_size((uint8_t*)l_emi), &l_emi_hash);
dap_assert(dap_ledger_token_emission_add(a_ledger, (byte_t*)l_emi, dap_chain_datum_emission_get_size((byte_t*)l_emi),
- &l_emi_hash, false) != 0,
+ &l_emi_hash) != 0,
"Checking the impossibility of emission to an address not from the white list.");
//Emission in white list
dap_chain_datum_token_emission_t *l_emi_whi = dap_chain_datum_emission_create(
@@ -825,7 +825,7 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
dap_chain_hash_fast_t l_emi_whi_hash = {0};
dap_hash_fast(l_emi_whi, dap_chain_datum_emission_get_size((uint8_t*)l_emi_whi), &l_emi_whi_hash);
dap_assert_PIF(!dap_ledger_token_emission_add(a_ledger, (byte_t*)l_emi_whi, dap_chain_datum_emission_get_size((byte_t*)l_emi_whi),
- &l_emi_whi_hash, false),
+ &l_emi_whi_hash),
"Can't add emission in white address");
dap_chain_datum_tx_t *l_btx_addr1 = dap_ledger_test_create_datum_base_tx(l_emi_whi, &l_emi_whi_hash,
*l_addr_1->addr, a_cert);
@@ -930,7 +930,7 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
dap_chain_hash_fast_t l_emi_block_hash = {0};
dap_hash_fast(l_emi_block, dap_chain_datum_emission_get_size((uint8_t*)l_emi_block), &l_emi_block_hash);
dap_assert(dap_ledger_token_emission_add(a_ledger, (byte_t*)l_emi_block, dap_chain_datum_emission_get_size((byte_t*)l_emi_block),
- &l_emi_block_hash, false),
+ &l_emi_block_hash),
"Test for emission rejection to an address from the prohibited list.");
//Check emission at addr
dap_chain_datum_token_emission_t *l_emi = dap_chain_datum_emission_create(
@@ -939,7 +939,7 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
dap_chain_hash_fast_t l_emi_hash = {0};
dap_hash_fast(l_emi, dap_chain_datum_emission_get_size((uint8_t*)l_emi), &l_emi_hash);
dap_assert(!dap_ledger_token_emission_add(a_ledger, (byte_t*)l_emi, dap_chain_datum_emission_get_size((byte_t*)l_emi),
- &l_emi_hash, false),
+ &l_emi_hash),
"Emission test for a non-blacklisted address.");
dap_chain_datum_tx_t *l_btx_addr2 = dap_ledger_test_create_datum_base_tx(l_emi, &l_emi_hash,
*l_addr_2->addr, a_cert);
@@ -1020,7 +1020,7 @@ void dap_ledger_test_run(void){
dap_hash_fast(l_emi, l_emi_size, &l_emi_hash);
int l_emi_check = dap_ledger_token_emission_add_check(l_ledger, (byte_t*)l_emi_sign, l_emi_size, &l_emi_hash);
dap_assert_PIF(l_emi_check == 0, "check emission for add in ledger");
- dap_assert_PIF(!dap_ledger_token_emission_add(l_ledger, (byte_t*)l_emi_sign, l_emi_size, &l_emi_hash, false), "Added emission in ledger");
+ dap_assert_PIF(!dap_ledger_token_emission_add(l_ledger, (byte_t*)l_emi_sign, l_emi_size, &l_emi_hash), "Added emission in ledger");
// Declarate delegated token
dap_chain_datum_token_tsd_delegate_from_stake_lock_t l_tsd_section;
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index da5b9e9d81bd476a6556a0edd34a50fda5610771..d847a21cbea45c92663c098c71c98d91dfe55a81 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -970,7 +970,7 @@ void dap_chain_datum_dump_json(json_object *a_obj_out, dap_chain_datum_t *a_dat
json_object_object_add(json_obj_datum,"coins", json_object_new_string(l_coins_str));
json_object_object_add(json_obj_datum,"value", json_object_new_string(l_value_str));
json_object_object_add(json_obj_datum,"ticker", json_object_new_string(l_emission->hdr.ticker));
- json_object_object_add(json_obj_datum,"type", json_object_new_string(c_dap_chain_datum_token_emission_type_str[l_emission->hdr.type]));
+ json_object_object_add(json_obj_datum,"type", json_object_new_string(dap_chain_datum_emission_type_str(l_emission->hdr.type)));
json_object_object_add(json_obj_datum,"version", json_object_new_uint64(l_emission->hdr.version));
json_object_object_add(json_obj_datum,"to addr", json_object_new_string(dap_chain_addr_to_str(&(l_emission->hdr.address))));
@@ -988,7 +988,7 @@ void dap_chain_datum_dump_json(json_object *a_obj_out, dap_chain_datum_t *a_dat
break;
}
dap_chain_datum_token_certs_dump_to_json(json_obj_datum, l_emission->tsd_n_signs + l_emission->data.type_auth.tsd_total_size,
- l_emission->data.type_auth.size - l_emission->data.type_auth.tsd_total_size, a_hash_out_type);
+ l_emission->data.type_auth.tsd_n_signs_size - l_emission->data.type_auth.tsd_total_size, a_hash_out_type);
break;
case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
json_object_object_add(json_obj_datum,"codename",json_object_new_string(l_emission->data.type_algo.codename));
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 30a7eccab318c9d17f95c5b733ddc152cc7ac322..8be5bcfd4bb3946399f51bf86e462cc3f0377ceb 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -32,30 +32,31 @@
#define LOG_TAG "dap_chain_datum_token"
-const char *c_dap_chain_datum_token_emission_type_str[]={
- [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED] = "UNDEFINED",
- [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH] = "AUTH",
- [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO] = "ALGO",
- [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER] = "OWNER",
- [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT] = "SMART_CONTRACT"
+struct datum_token_flag_struct {
+ const char *key;
+ uint32_t val;
};
-const char *c_dap_chain_datum_token_flag_str[] = {
- [DAP_CHAIN_DATUM_TOKEN_FLAG_NONE] = "NONE",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED] = "ALL_SENDER_BLOCKED",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED] = "ALL_SENDER_ALLOWED",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN] = "ALL_SENDER_FROZEN",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN] = "ALL_SENDER_UNFROZEN",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED] = "ALL_RECEIVER_BLOCKED",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED] = "ALL_RECEIVER_ALLOWED",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN] = "ALL_RECEIVER_FROZEN",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN] = "ALL_RECEIVER_UNFROZEN",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL] = "STATIC_ALL",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS] = "STATIC_FLAGS",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL] = "STATIC_PERMISSIONS_ALL",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE] = "STATIC_PERMISSIONS_DATUM_TYPE",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER] = "TATIC_PERMISSIONS_TX_SENDER",
- [DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER] = "STATIC_PERMISSIONS_TX_RECEIVER",
+static const struct datum_token_flag_struct s_flags_table[] = {
+ { "NO_FLAGS", DAP_CHAIN_DATUM_TOKEN_FLAG_NONE },
+ { "ALL_BLOCKED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED },
+ { "ALL_FROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN },
+ { "ALL_ALLOWED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED },
+ { "ALL_UNFROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN },
+ { "STATIC_ALL", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL },
+ { "STATIC_FLAGS", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS },
+ { "STATIC_PERMISSIONS_ALL", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL },
+ { "STATIC_PERMISSIONS_DATUM_TYPE", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE },
+ { "STATIC_PERMISSIONS_TX_SENDER", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER },
+ { "STATIC_PERMISSIONS_TX_RECEIVER", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER },
+ { "ALL_SENDER_BLOCKED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED },
+ { "ALL_SENDER_FROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN },
+ { "ALL_SENDER_ALLOWED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED },
+ { "ALL_SENDER_UNFROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN },
+ { "ALL_RECEIVER_BLOCKED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED },
+ { "ALL_RECEIVER_FROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN },
+ { "ALL_RECEIVER_ALLOWED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED },
+ { "ALL_RECEIVER_UNFROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN }
};
/**
@@ -174,29 +175,18 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(const byte_t *a_token_serial
}
/**
- * @brief dap_chain_datum_token_flags_dump
- * @param a_str_out
- * @param a_flags
+ * @brief dap_chain_datum_token_flag_from_str
+ * @param a_str
+ * @return
*/
-void dap_chain_datum_token_flags_dump(dap_string_t * a_str_out, uint16_t a_flags)
+uint32_t dap_chain_datum_token_flag_from_str(const char *a_str)
{
- if(!a_flags){
- dap_string_append_printf(a_str_out, "%s\n",
- c_dap_chain_datum_token_flag_str[DAP_CHAIN_DATUM_TOKEN_FLAG_NONE]);
- return;
- }
- bool is_first = true;
- for ( uint16_t i = 0; BIT(i) <= DAP_CHAIN_DATUM_TOKEN_FLAG_MAX; i++){
- if( a_flags & (1 << i) ){
- if(is_first)
- is_first = false;
- else
- dap_string_append_printf(a_str_out,", ");
- dap_string_append_printf(a_str_out,"%s", c_dap_chain_datum_token_flag_str[BIT(i)]);
- }
- if(i == DAP_CHAIN_DATUM_TOKEN_FLAG_MAX)
- dap_string_append_printf(a_str_out, "\n");
- }
+ if (a_str == NULL)
+ return DAP_CHAIN_DATUM_TOKEN_FLAG_NONE;
+ for (uint16_t i = 0; i < sizeof(s_flags_table) / sizeof(struct datum_token_flag_struct); i++)
+ if (strcmp(s_flags_table[i].key, a_str) == 0)
+ return s_flags_table[i].val;
+ return DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED;
}
/**
@@ -206,23 +196,17 @@ void dap_chain_datum_token_flags_dump(dap_string_t * a_str_out, uint16_t a_flags
*/
void dap_chain_datum_token_flags_dump_to_json(json_object * json_obj_out, uint16_t a_flags)
{
- if(!a_flags){
- json_object_object_add(json_obj_out, "flags", json_object_new_string(c_dap_chain_datum_token_flag_str[DAP_CHAIN_DATUM_TOKEN_FLAG_NONE]));
-
+ if (!a_flags) {
+ json_object_object_add(json_obj_out, "flags", json_object_new_string(dap_chain_datum_token_flag_to_str(DAP_CHAIN_DATUM_TOKEN_FLAG_NONE)));
return;
}
json_object *l_array_flags = json_object_new_array();
- for ( uint16_t i = 0; BIT(i) <= DAP_CHAIN_DATUM_TOKEN_FLAG_MAX; i++){
- if( a_flags & (1 << i) ){
- json_object_array_add(l_array_flags, json_object_new_string(c_dap_chain_datum_token_flag_str[BIT(i)]));
-
- }
- }
+ for (uint16_t i = 0; BIT(i) <= DAP_CHAIN_DATUM_TOKEN_FLAG_MAX; i++)
+ if (a_flags & BIT(i))
+ json_object_array_add(l_array_flags, json_object_new_string(dap_chain_datum_token_flag_to_str(BIT(i))));
json_object_object_add(json_obj_out, "flags", l_array_flags);
}
-
-
/**
* @brief dap_chain_datum_token_certs_dump
* @param a_str_out
@@ -357,16 +341,12 @@ size_t dap_chain_datum_emission_get_size(uint8_t *a_emission_serial)
dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emission_serial, size_t *a_emission_size)
{
- assert(a_emission_serial);
- assert(a_emission_size);
- if(!a_emission_serial || !a_emission_size || *a_emission_size < sizeof(struct dap_chain_emission_header_v0)) {
- log_it(L_ERROR, "Invalid params in dap_chain_datum_emission_read");
- return NULL;
- }
+ const size_t l_old_hdr_size = sizeof(struct dap_chain_emission_header_v0);
+ dap_return_val_if_fail(a_emission_serial && a_emission_size && *a_emission_size >= l_old_hdr_size, NULL);
+
dap_chain_datum_token_emission_t *l_emission = NULL;
if (((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.version == 0) {
size_t l_emission_size = *a_emission_size;
- size_t l_old_hdr_size = sizeof(struct dap_chain_emission_header_v0);
size_t l_add_size = sizeof(l_emission->hdr) - l_old_hdr_size;
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_emission_size + l_add_size);
if (!l_emission) {
@@ -381,16 +361,25 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emissi
l_emission->hdr.value = dap_chain_uint256_from(
((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.value64);
l_emission_size += l_add_size;
+ if (l_emission->hdr.type == DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH)
+ l_emission->data.type_auth.tsd_n_signs_size = l_emission_size - sizeof(dap_chain_datum_token_emission_t);
(*a_emission_size) = l_emission_size;
} else {
+ if (((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.version == 1) {
+ l_emission->hdr.value = dap_chain_uint256_from(
+ ((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.value64);
+ l_emission->hdr.version = 2;
+ }
+ if (*a_emission_size < sizeof(dap_chain_datum_token_emission_t)) {
+ log_it(L_WARNING, "Size of emission is %zu, less than header size %zu",
+ *a_emission_size, sizeof(dap_chain_datum_token_emission_t));
+ return NULL;
+ }
l_emission = DAP_DUP_SIZE(a_emission_serial, *a_emission_size);
if (!l_emission) {
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
return NULL;
}
- if (((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.version == 1)
- l_emission->hdr.value = dap_chain_uint256_from(
- ((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.value64);
}
return l_emission;
}
@@ -406,7 +395,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_add_tsd(dap_chain_dat
memcpy(l_emission->tsd_n_signs + l_emission->data.type_auth.tsd_total_size, l_tsd, l_tsd_size);
DAP_DELETE(l_tsd);
l_emission->data.type_auth.tsd_total_size += l_tsd_size;
- l_emission->data.type_auth.size += l_tsd_size;
+ l_emission->data.type_auth.tsd_n_signs_size += l_tsd_size;
return l_emission;
}
@@ -431,9 +420,9 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_add_sign(dap_enc_key_
return NULL;
size_t l_signs_count = a_emission->data.type_auth.signs_count;
- size_t l_old_signs_size = a_emission->data.type_auth.size;
+ size_t l_old_signs_size = a_emission->data.type_auth.tsd_n_signs_size;
- if (a_emission->data.type_auth.size > a_emission->data.type_auth.tsd_total_size)
+ if (a_emission->data.type_auth.tsd_n_signs_size > a_emission->data.type_auth.tsd_total_size)
{
size_t l_pub_key_size = 0;
dap_sign_t *l_sign = (dap_sign_t *)(a_emission->tsd_n_signs + a_emission->data.type_auth.tsd_total_size);
@@ -447,7 +436,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_add_sign(dap_enc_key_
DAP_DELETE(l_pub_key);
}
a_emission->data.type_auth.signs_count = 0;
- a_emission->data.type_auth.size = 0;
+ a_emission->data.type_auth.tsd_n_signs_size = 0;
dap_sign_t *l_new_sign = dap_sign_create(a_sign_key, a_emission, sizeof(dap_chain_datum_token_emission_t) + a_emission->data.type_auth.tsd_total_size, 0);
if (!l_new_sign)
return NULL;
@@ -458,7 +447,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_add_sign(dap_enc_key_
DAP_DELETE(l_new_sign);
l_old_signs_size += l_sign_size;
l_signs_count++;
- l_ret->data.type_auth.size = l_old_signs_size;
+ l_ret->data.type_auth.tsd_n_signs_size = l_old_signs_size;
l_ret->data.type_auth.signs_count = l_signs_count;
return l_ret;
}
@@ -471,7 +460,7 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_append_sign(dap_sign_
if (!a_sign)
return NULL;
- if (a_emission->data.type_auth.size > a_emission->data.type_auth.tsd_total_size)
+ if (a_emission->data.type_auth.tsd_n_signs_size > a_emission->data.type_auth.tsd_total_size)
{
dap_sign_t *l_sign = (dap_sign_t *)(a_emission->tsd_n_signs + a_emission->data.type_auth.tsd_total_size);
for (int i = 0; i < a_emission->data.type_auth.signs_count; i++) {
@@ -488,9 +477,9 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_append_sign(dap_sign_
size_t l_emission_size = dap_chain_datum_emission_get_size((uint8_t *)a_emission);
dap_chain_datum_token_emission_t *l_ret = DAP_REALLOC(a_emission, l_emission_size + dap_sign_get_size(a_sign));
size_t l_sign_size = dap_sign_get_size(a_sign);
- memcpy(l_ret->tsd_n_signs + l_ret->data.type_auth.size, a_sign, l_sign_size);
+ memcpy(l_ret->tsd_n_signs + l_ret->data.type_auth.tsd_n_signs_size, a_sign, l_sign_size);
- l_ret->data.type_auth.size += l_sign_size;
+ l_ret->data.type_auth.tsd_n_signs_size += l_sign_size;
l_ret->data.type_auth.signs_count++;
return l_ret;
}
@@ -501,12 +490,12 @@ dap_sign_t *dap_chain_datum_emission_get_signs(dap_chain_datum_token_emission_t
log_it(L_ERROR, "Parameters must be not-null!");
return NULL;
}
- if (!a_emission->data.type_auth.signs_count || a_emission->data.type_auth.size <= a_emission->data.type_auth.tsd_total_size) {
+ if (!a_emission->data.type_auth.signs_count || a_emission->data.type_auth.tsd_n_signs_size <= a_emission->data.type_auth.tsd_total_size) {
*a_signs_count = 0;
log_it(L_INFO, "No signes found");
return NULL;
}
- size_t l_expected_size = a_emission->data.type_auth.size - a_emission->data.type_auth.tsd_total_size, l_actual_size = 0;
+ size_t l_expected_size = a_emission->data.type_auth.tsd_n_signs_size - a_emission->data.type_auth.tsd_total_size, l_actual_size = 0;
/* First sign */
dap_sign_t *l_sign = (dap_sign_t*)(a_emission->tsd_n_signs + a_emission->data.type_auth.tsd_total_size);
size_t l_count, l_sign_size;
diff --git a/modules/common/include/dap_chain_datum_token.h b/modules/common/include/dap_chain_datum_token.h
index fbd34ed4db77ed1dbaa60977c7121170eedcedd0..04a469261564173fa0c4c438a30018e4a823a7b6 100644
--- a/modules/common/include/dap_chain_datum_token.h
+++ b/modules/common/include/dap_chain_datum_token.h
@@ -169,70 +169,72 @@ typedef struct dap_chain_datum_token_tsd_delegate_from_stake_lock {
// Macros for token flags
/// ------- Global section flags --------
// No any flags
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_NONE 0x0000
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_NONE 0x0000
// Blocked all permissions, usefull issue it by default and then allow what you want to allow
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED BIT(1)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED BIT(1)
// Allowed all permissions if not blocked them. Be careful with this mode
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED BIT(2)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED BIT(2)
// All permissions are temprorary frozen
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN BIT(3)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN BIT(3)
// Unfrozen permissions
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN BIT(4)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN BIT(4)
// Blocked all permissions, usefull issue it by default and then allow what you want to allow
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED BIT(5)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED BIT(5)
// Allowed all permissions if not blocked them. Be careful with this mode
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED BIT(6)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED BIT(6)
// All permissions are temprorary frozen
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN BIT(7)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN BIT(7)
// Unfrozen permissions
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN BIT(8)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN BIT(8)
/// ------ Static configured flags
// No token manipulations after declarations at all. Token declares staticly and can't variabed after
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL BIT(9)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL BIT(9)
// No token manipulations after declarations with flags.
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS BIT(10)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS BIT(10)
// No all permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL BIT(11)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL BIT(11)
// No datum type permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE BIT(12)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE BIT(12)
// No tx sender permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER BIT(13)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER BIT(13)
// No tx receiver permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER BIT(14)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER BIT(14)
// Maximal flag
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_MAX BIT(15)
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_MAX BIT(15)
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED 0xffff
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED 0xffff
-extern const char *c_dap_chain_datum_token_flag_str[];
-
-#define dap_chain_datum_token_flag_to_str(a) ((a<=DAP_CHAIN_DATUM_TOKEN_FLAG_MAX) ? c_dap_chain_datum_token_flag_str[a] : "OUT_OF_RANGE")
-
-
-// /**
-// * @brief dap_chain_datum_token_flag_from_str
-// * @param a_str
-// * @return
-// */
-// static inline uint16_t dap_chain_datum_token_flag_from_str(const char* a_str)
-// {
-// if (a_str == NULL)
-// return DAP_CHAIN_DATUM_TOKEN_FLAG_NONE;
+DAP_STATIC_INLINE const char *dap_chain_datum_token_flag_to_str(uint32_t a_flag)
+{
+ switch (a_flag) {
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_NONE: return "NONE";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED: return "ALL_SENDER_BLOCKED";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED: return "ALL_SENDER_ALLOWED";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN: return "ALL_SENDER_FROZEN";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN: return "ALL_SENDER_UNFROZEN";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED: return "ALL_RECEIVER_BLOCKED";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED: return "ALL_RECEIVER_ALLOWED";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN: return "ALL_RECEIVER_FROZEN";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN: return "ALL_RECEIVER_UNFROZEN";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL: return "STATIC_ALL";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS: return "STATIC_FLAGS";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL: return "STATIC_PERMISSIONS_ALL";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE: return "STATIC_PERMISSIONS_DATUM_TYPE";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER: return "TATIC_PERMISSIONS_TX_SENDER";
+ case DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER: return "STATIC_PERMISSIONS_TX_RECEIVER";
+ default: return "UNKNOWN FLAG OR FLAGS GROUP";
+ }
+}
-// for (uint16_t i = DAP_CHAIN_DATUM_TOKEN_FLAG_NONE; i <=DAP_CHAIN_DATUM_TOKEN_FLAG_MAX; i++ ){
-// if ( strcmp( a_str, c_dap_chain_datum_token_flag_str[i]) == 0 )
-// return i;
-// }
-// return DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED;
-// }
+uint32_t dap_chain_datum_token_flag_from_str(const char *a_str);
/// -------- General tsd types ----
// Flags set/unsed
@@ -257,142 +259,41 @@ extern const char *c_dap_chain_datum_token_flag_str[];
// Description token
#define DAP_CHAIN_DATUM_TOKEN_TSD_TOKEN_DESCRIPTION 0x0028
-
-
-
/// ------- Permissions list flags, grouped by update-remove-clear operations --------
// Blocked datum types list add, remove or clear
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_ADD 0x0007
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_REMOVE 0x0008
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_CLEAR 0x0009
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_ADD 0x0007
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_REMOVE 0x0008
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_CLEAR 0x0009
// Allowed datum types list add, remove or clear
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_ADD 0x0010
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_REMOVE 0x0011
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_CLEAR 0x0012
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_ADD 0x0010
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_REMOVE 0x0011
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_CLEAR 0x0012
//Allowed tx receiver addres list add, remove or clear
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD 0x0014
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_REMOVE 0x0015
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_CLEAR 0x0016
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD 0x0014
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_REMOVE 0x0015
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_CLEAR 0x0016
//Blocked tx receiver addres list add, remove or clear
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD 0x0017
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_REMOVE 0x0018
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_CLEAR 0x0019
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD 0x0017
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_REMOVE 0x0018
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_CLEAR 0x0019
//Allowed tx sender addres list add, remove or clear
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD 0x0020
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_REMOVE 0x0021
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_CLEAR 0x0022
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD 0x0020
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_REMOVE 0x0021
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_CLEAR 0x0022
//Blocked tx sender addres list add, remove or clear
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD 0x0023
-#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
-
-typedef struct { char *key; uint64_t val; } t_datum_token_flag_struct;
-
-// new__
-static t_datum_token_flag_struct s_flags_table[] = {
- { "NO_FLAGS", DAP_CHAIN_DATUM_TOKEN_FLAG_NONE},
- { "ALL_BLOCKED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED},
- { "ALL_FROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN },
- { "ALL_ALLOWED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED},
- { "ALL_UNFROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN | DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN },
- { "STATIC_ALL", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL},
- { "STATIC_FLAGS", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS },
- { "STATIC_PERMISSIONS_ALL", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL },
- { "STATIC_PERMISSIONS_DATUM_TYPE", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE },
- { "STATIC_PERMISSIONS_TX_SENDER", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER },
- { "STATIC_PERMISSIONS_TX_RECEIVER", DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER },
- { "ALL_SENDER_BLOCKED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED},
- { "ALL_SENDER_FROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN},
- { "ALL_SENDER_ALLOWED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED},
- { "ALL_SENDER_UNFROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN},
- { "ALL_RECEIVER_BLOCKED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED},
- { "ALL_RECEIVER_FROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN },
- { "ALL_RECEIVER_ALLOWED", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED},
- { "ALL_RECEIVER_UNFROZEN", DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN },
-};
-
-
-#define NKEYS (sizeof(s_flags_table)/sizeof(t_datum_token_flag_struct))
-
-DAP_STATIC_INLINE int s_flag_code_from_str(const char *key)
-{
- uint64_t i;
- for (i=0; i < NKEYS; i++) {
- t_datum_token_flag_struct sym = s_flags_table[i];
- if (strcmp(s_flags_table[i].key, key) == 0)
- return s_flags_table[i].val;
- }
-
- return DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED;
-}
-
-DAP_STATIC_INLINE char* s_flag_str_from_code(uint64_t code)
-{
- uint64_t i;
- uint64_t flags_count = 0;
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD 0x0023
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_REMOVE 0x0024
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_CLEAR 0x0025
- for (i=0; i < NKEYS; i++) {
- t_datum_token_flag_struct sym = s_flags_table[i];
- if (s_flags_table[i].val == code)
- return s_flags_table[i].key;
- }
-
- // split multiple flags in string
-
- char* s_multiple_flag = "";
-
- for (i=0; i < NKEYS; i++) {
- t_datum_token_flag_struct sym = s_flags_table[i];
- if ((s_flags_table[i].val & code) > 0)
- {
- flags_count += 1;
- if (flags_count > 1)
- s_multiple_flag = dap_strjoin(";", s_multiple_flag, s_flags_table[i].key, (char*)NULL);
- else
- s_multiple_flag = dap_strjoin(NULL, s_multiple_flag, s_flags_table[i].key, (char*)NULL);
- }
- }
-
- char* s_no_flags = "NO FLAGS";
-
- if (flags_count > 0)
- return s_multiple_flag;
- else
- return s_no_flags;
-}
-
-/**
- * @brief dap_chain_datum_token_flag_from_str
- * @param a_str
- * @return
- */
-DAP_STATIC_INLINE char *dap_chain_datum_str_token_flag_from_code(uint64_t code)
-{
- return s_flag_str_from_code(code);
-}
-
-/**
- * @brief dap_chain_datum_token_flag_from_str
- * @param a_str
- * @return
- */
-DAP_STATIC_INLINE uint16_t dap_chain_datum_token_flag_from_str(const char* a_str)
-{
- if (a_str == NULL)
- return DAP_CHAIN_DATUM_TOKEN_FLAG_NONE;
-
- return s_flag_code_from_str(a_str);
-}
+#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)
@@ -451,7 +352,7 @@ typedef struct dap_chain_datum_token_emission {
char codename[32];
} DAP_ALIGN_PACKED type_algo;
struct {
- uint64_t size;
+ uint64_t tsd_n_signs_size;
uint64_t tsd_total_size;
uint16_t signs_count;
} DAP_ALIGN_PACKED type_auth;
@@ -501,12 +402,20 @@ typedef struct dap_chain_datum_token_emission {
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_BRIDGE_COMMISSION "COMMISSION"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_BRIDGE_CROSSCHAIN "CROSSCHAIN"
-
-extern const char *c_dap_chain_datum_token_emission_type_str[];
+DAP_STATIC_INLINE const char *dap_chain_datum_emission_type_str(uint8_t a_type)
+{
+ switch (a_type) {
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH: return "AUTH";
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO: return "ALGO";
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER: return "OWNER";
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT: return "SMART_CONTRACT";
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
+ default: return "UNDEFINED";
+ }
+}
/// TDS op funcs
dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, size_t a_token_size);
-void dap_chain_datum_token_flags_dump(dap_string_t * a_str_out, uint16_t a_flags);
void dap_chain_datum_token_flags_dump_to_json(json_object * json_obj_out, uint16_t a_flags);
void dap_chain_datum_token_certs_dump(dap_string_t * a_str_out, byte_t * a_tsd_n_signs, size_t a_certs_size, const char *a_hash_out_type);
void dap_chain_datum_token_certs_dump_to_json(json_object *a_json_obj_out, byte_t * a_tsd_n_signs, size_t a_certs_size, const char *a_hash_out_type);
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index 2fec03b9320c1ed8d781fc2adfbdcd6e7342ce50..a3e9354c0d7ee6330bf74607218c2397b6236a17 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -872,7 +872,7 @@ static int s_callback_event_round_sync(dap_chain_cs_dag_t * a_dag, const char a_
return -1;
}
if (l_event->header.round_id < a_dag->round_completed) {
- struct round_timer_arg *l_round_active;
+ struct round_timer_arg *l_round_active = NULL;
uint64_t l_round_id = l_event->header.round_id;
pthread_rwlock_wrlock(&l_poa_pvt->rounds_rwlock);
HASH_FIND(hh, l_poa_pvt->active_rounds, &l_round_id, sizeof(uint64_t), l_round_active);
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 6f12359e7035d108ee94a4fae35dffb1c0b2e3e3..4867bb7d90175e7af7f01a893e1bb35bd3f742b0 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -1068,7 +1068,7 @@ static bool s_session_round_new(void *a_arg)
a_session->cur_round.all_validators = dap_list_copy_deep(l_validators, s_callback_list_form, NULL);
dap_list_free_full(l_validators, NULL);
bool l_round_already_started = a_session->round_fast_forward;
- dap_chain_esbocs_sync_item_t *l_item, *l_tmp;
+ dap_chain_esbocs_sync_item_t *l_item = NULL, *l_tmp;
HASH_FIND(hh, a_session->sync_items, &a_session->cur_round.last_block_hash, sizeof(dap_hash_fast_t), l_item);
if (l_item) {
debug_if(PVT(a_session->esbocs)->debug,
@@ -1307,7 +1307,7 @@ static void s_session_state_change(dap_chain_esbocs_session_t *a_session, enum s
if (dap_hash_fast_is_blank(l_candidate_hash))
s_session_attempt_new(a_session);
else {
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
HASH_FIND(hh, a_session->cur_round.store_items, l_candidate_hash, sizeof(dap_chain_hash_fast_t), l_store);
if (l_store) {
a_session->cur_round.attempt_candidate_hash = *l_candidate_hash;
@@ -1340,7 +1340,7 @@ static void s_session_state_change(dap_chain_esbocs_session_t *a_session, enum s
} break;
case DAP_CHAIN_ESBOCS_SESSION_STATE_WAIT_FINISH: {
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
HASH_FIND(hh, a_session->cur_round.store_items, &a_session->cur_round.attempt_candidate_hash, sizeof(dap_hash_fast_t), l_store);
if (!l_store) {
log_it(L_ERROR, "No finish candidate found!");
@@ -1458,7 +1458,7 @@ static void s_session_proc_state(void *a_arg)
break;
case DAP_CHAIN_ESBOCS_SESSION_STATE_WAIT_SIGNS:
if (l_time - l_session->ts_stage_entry >= PVT(l_session->esbocs)->round_attempt_timeout) {
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
HASH_FIND(hh, l_session->cur_round.store_items, &l_session->cur_round.attempt_candidate_hash, sizeof(dap_hash_fast_t), l_store);
if (!l_store) {
log_it(L_ERROR, "No round candidate found!");
@@ -1634,7 +1634,7 @@ static void s_session_candidate_precommit(dap_chain_esbocs_session_t *a_session,
uint16_t l_cs_level = PVT(a_session->esbocs)->min_validators_count;
byte_t *l_message_data = a_message->msg_n_sign;
dap_chain_hash_fast_t *l_candidate_hash = &a_message->hdr.candidate_hash;
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
const char *l_candidate_hash_str = NULL;
HASH_FIND(hh, a_session->cur_round.store_items, l_candidate_hash, sizeof(dap_chain_hash_fast_t), l_store);
if (!l_store) {
@@ -1779,7 +1779,7 @@ void s_session_sync_queue_add(dap_chain_esbocs_session_t *a_session, dap_chain_e
log_it(L_CRITICAL, "%s", c_error_memory_alloc);
return;
}
- dap_chain_esbocs_sync_item_t *l_sync_item;
+ dap_chain_esbocs_sync_item_t *l_sync_item = NULL;
HASH_FIND(hh, a_session->sync_items, &a_message->hdr.candidate_hash, sizeof(dap_hash_fast_t), l_sync_item);
if (!l_sync_item) {
DAP_NEW_Z_RET(l_sync_item, dap_chain_esbocs_sync_item_t, l_message_copy);
@@ -2396,7 +2396,7 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
l_message->hdr.attempt_num, l_candidate_hash_str, l_candidate_size);
}
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
HASH_FIND(hh, l_session->cur_round.store_items, l_candidate_hash, sizeof(dap_chain_hash_fast_t), l_store);
if (l_store) {
const char *l_candidate_hash_str = dap_chain_hash_fast_to_str_static(l_candidate_hash);
@@ -2426,7 +2426,7 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
case DAP_CHAIN_ESBOCS_MSG_TYPE_APPROVE:
case DAP_CHAIN_ESBOCS_MSG_TYPE_REJECT: {
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
const char *l_candidate_hash_str = NULL;
bool l_approve = l_message->hdr.type == DAP_CHAIN_ESBOCS_MSG_TYPE_APPROVE;
HASH_FIND(hh, l_session->cur_round.store_items, l_candidate_hash, sizeof(dap_chain_hash_fast_t), l_store);
@@ -2493,7 +2493,7 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
break;
}
- dap_chain_esbocs_store_t *l_store;
+ dap_chain_esbocs_store_t *l_store = NULL;
const char *l_candidate_hash_str = NULL;
HASH_FIND(hh, l_session->cur_round.store_items, l_candidate_hash, sizeof(dap_chain_hash_fast_t), l_store);
if (!l_store) {
diff --git a/modules/net/dap_chain_ledger.c b/modules/net/dap_chain_ledger.c
index e5b41bacbfcbf3efb30caacb267eaa40239095c4..8f01ec2503542f1c2dd2a01e00609e69253e8de5 100644
--- a/modules/net/dap_chain_ledger.c
+++ b/modules/net/dap_chain_ledger.c
@@ -158,7 +158,7 @@ typedef struct dap_ledger_tx_item {
dap_chain_datum_tx_t *tx;
dap_nanotime_t ts_added;
struct {
- dap_time_t ts_created;
+ dap_time_t ts_created; // Transation datum timestamp mirrored & cached
uint32_t n_outs;
uint32_t n_outs_used;
char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
@@ -239,61 +239,54 @@ typedef struct dap_ledger_bridged_tx_notifier {
void *arg;
} dap_ledger_bridged_tx_notifier_t;
-// dap_ledget_t private section
-typedef struct dap_ledger_private {
- // List of ledger - unspent transactions cache
- dap_ledger_tx_item_t *threshold_txs;
- dap_ledger_token_emission_item_t * threshold_emissions;
+typedef struct dap_ledger_hal_item {
+ dap_chain_hash_fast_t hash;
+ UT_hash_handle hh;
+} dap_ledger_hal_item_t;
+// dap_ledger_t private section
+typedef struct dap_ledger_private {
+ // separate access to transactions
+ pthread_rwlock_t ledger_rwlock;
dap_ledger_tx_item_t *ledger_items;
+ // separate access to tokens
+ pthread_rwlock_t tokens_rwlock;
dap_ledger_token_item_t *tokens;
+ // separate acces to stake items
+ pthread_rwlock_t stake_lock_rwlock;
dap_ledger_stake_lock_item_t *emissions_for_stake_lock;
+ // separate access to rewards
+ pthread_rwlock_t rewards_rwlock;
dap_ledger_reward_item_t *rewards;
+ // separate access to balances
+ pthread_rwlock_t balance_accounts_rwlock;
dap_ledger_wallet_balance_t *balance_accounts;
-
- // for separate access to transactions
- pthread_rwlock_t ledger_rwlock;
- // for separate access to tokens
- pthread_rwlock_t tokens_rwlock;
- pthread_rwlock_t stake_lock_rwlock;
+ // separate access to threshold
+ dap_ledger_tx_item_t *threshold_txs;
pthread_rwlock_t threshold_txs_rwlock;
- pthread_rwlock_t threshold_emissions_rwlock;
- pthread_rwlock_t balance_accounts_rwlock;
- pthread_rwlock_t rewards_rwlock;
-
+ dap_interval_timer_t threshold_txs_free_timer;
// Save/load operations condition
pthread_mutex_t load_mutex;
pthread_cond_t load_cond;
bool load_end;
-
// Ledger flags
- bool check_ds, check_cells_ds, check_token_emission, cached, mapped;
-
+ bool check_ds, check_cells_ds, check_token_emission, cached, mapped, threshold_enabled;
dap_chain_cell_id_t local_cell_id;
-
//notifiers
dap_list_t *bridged_tx_notifiers;
dap_list_t *tx_add_notifiers;
-
dap_ledger_cache_tx_check_callback_t cache_tx_check_callback;
- // Threshold fee
- dap_interval_timer_t threshold_txs_free_timer, threshold_emissions_free_timer;
+ // HAL
+ dap_ledger_hal_item_t *hal_items;
} dap_ledger_private_t;
-#define PVT(a) ( (dap_ledger_private_t* ) a->_internal )
-
-typedef struct dap_ledger_hal_item {
- dap_chain_hash_fast_t hash;
- UT_hash_handle hh;
-} dap_ledger_hal_item_t;
-static dap_ledger_hal_item_t *s_hal_items = NULL;
+#define PVT(a) ( (dap_ledger_private_t *) a->_internal )
static dap_ledger_tx_item_t* tx_item_find_by_addr(dap_ledger_t *a_ledger,
const dap_chain_addr_t *a_addr, const char * a_token, dap_chain_hash_fast_t *a_tx_first_hash);
static void s_threshold_emissions_proc( dap_ledger_t * a_ledger);
static void s_threshold_txs_proc( dap_ledger_t * a_ledger);
static void s_threshold_txs_free(dap_ledger_t *a_ledger);
-static void s_threshold_emission_free(dap_ledger_t *a_ledger);
static int s_sort_ledger_tx_item(dap_ledger_tx_item_t* a, dap_ledger_tx_item_t* b);
static size_t s_threshold_emissions_max = 1000;
@@ -386,14 +379,12 @@ static bool s_tag_check_transfer(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a
}
}
-
//regular transfers
//have no other ins except regular in
//have no OUT_COND except fee
//have no vote
//no TSD!
-
//have any of those -> not regular transfer
if (a_items_grp->items_in_cond ||
a_items_grp->items_in_ems ||
@@ -423,7 +414,7 @@ static bool s_tag_check_transfer(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a
int dap_ledger_service_add(dap_chain_net_srv_uid_t a_uid, char *tag_str, dap_ledger_tag_check_callback_t a_callback)
{
- dap_ledger_service_info_t *l_new_sinfo;
+ dap_ledger_service_info_t *l_new_sinfo = NULL;
int l_tmp = a_uid.raw_ui64;
@@ -507,14 +498,10 @@ static dap_ledger_t *dap_ledger_handle_new(void)
pthread_rwlock_init(&l_ledger_pvt->ledger_rwlock, NULL);
pthread_rwlock_init(&l_ledger_pvt->tokens_rwlock, NULL);
pthread_rwlock_init(&l_ledger_pvt->threshold_txs_rwlock , NULL);
- pthread_rwlock_init(&l_ledger_pvt->threshold_emissions_rwlock , NULL);
pthread_rwlock_init(&l_ledger_pvt->balance_accounts_rwlock , NULL);
pthread_rwlock_init(&l_ledger_pvt->stake_lock_rwlock, NULL);
pthread_rwlock_init(&l_ledger_pvt->rewards_rwlock, NULL);
- l_ledger_pvt->threshold_txs_free_timer = dap_interval_timer_create(s_threshold_free_timer_tick,
- (dap_timer_callback_t)s_threshold_txs_free, l_ledger);
- l_ledger_pvt->threshold_emissions_free_timer = dap_interval_timer_create(s_threshold_free_timer_tick,
- (dap_timer_callback_t) s_threshold_emission_free, l_ledger);
+
return l_ledger;
}
@@ -532,7 +519,6 @@ void dap_ledger_handle_free(dap_ledger_t *a_ledger)
pthread_rwlock_destroy(&PVT(a_ledger)->ledger_rwlock);
pthread_rwlock_destroy(&PVT(a_ledger)->tokens_rwlock);
pthread_rwlock_destroy(&PVT(a_ledger)->threshold_txs_rwlock);
- pthread_rwlock_destroy(&PVT(a_ledger)->threshold_emissions_rwlock);
pthread_rwlock_destroy(&PVT(a_ledger)->balance_accounts_rwlock);
pthread_rwlock_destroy(&PVT(a_ledger)->stake_lock_rwlock);
pthread_rwlock_destroy(&PVT(a_ledger)->rewards_rwlock);
@@ -568,10 +554,18 @@ struct json_object *wallet_info_json_collect(dap_ledger_t *a_ledger, dap_ledger_
return l_json;
}
+inline static dap_ledger_hal_item_t *s_check_hal(dap_ledger_t *a_ledger, dap_hash_fast_t *a_hal_hash)
+{
+ dap_ledger_hal_item_t *ret = NULL;
+ HASH_FIND(hh, PVT(a_ledger)->hal_items, a_hal_hash, sizeof(dap_hash_fast_t), ret);
+ debug_if(s_debug_more && ret, L_MSG, "Datum %s is whitelisted", dap_hash_fast_to_str_static(a_hal_hash));
+ return ret;
+}
+
inline static dap_ledger_token_item_t *s_ledger_find_token(dap_ledger_t *a_ledger, const char *a_token_ticker)
{
dap_return_val_if_fail(a_ledger && a_token_ticker, NULL);
- dap_ledger_token_item_t *l_token_item;
+ dap_ledger_token_item_t *l_token_item = NULL;
pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
HASH_FIND_STR(PVT(a_ledger)->tokens, a_token_ticker, l_token_item);
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
@@ -658,7 +652,7 @@ static int s_token_tsd_parse(dap_ledger_token_item_t *a_item_apply_to, dap_chain
goto ret_n_clear;
}
if (!a_item_apply_to) {
- log_it(L_WARNING, "Unexpected TOTAL_SUUPLY TSD section in datum token declaration");
+ log_it(L_WARNING, "Unexpected TOTAL_SUPPLY TSD section in datum token declaration");
ret = DAP_LEDGER_TOKEN_ADD_CHECK_TSD_FORBIDDEN;
goto ret_n_clear;
}
@@ -1361,6 +1355,12 @@ int s_token_add_check(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token_si
dap_chain_datum_token_t *l_token = dap_chain_datum_token_read(a_token, &l_token_size);
if (!l_token)
return DAP_LEDGER_CHECK_INVALID_SIZE;
+ bool l_legacy_type = a_token_size != l_token_size;
+ if (l_legacy_type && !a_token_item) { // It's mempool check
+ log_it(L_WARNING, "Legacy token type %hu isn't supported for a new declaration", l_token->type);
+ DAP_DELETE(l_token);
+ return DAP_LEDGER_TOKEN_ADD_CHECK_LEGACY_FORBIDDEN;
+ }
if (l_token->type != DAP_CHAIN_DATUM_TOKEN_TYPE_UPDATE && l_token->type != DAP_CHAIN_DATUM_TOKEN_TYPE_DECL) {
log_it(L_WARNING, "Unknown token type %hu", l_token->type);
DAP_DELETE(l_token);
@@ -1400,7 +1400,7 @@ int s_token_add_check(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token_si
return DAP_LEDGER_TOKEN_ADD_CHECK_NOT_ENOUGH_UNIQUE_SIGNS;
}
dap_hash_fast(l_token, l_token_size, &l_token_update_hash);
- dap_ledger_token_update_item_t *l_token_update_item;
+ dap_ledger_token_update_item_t *l_token_update_item = NULL;
pthread_rwlock_rdlock(&l_token_item->token_ts_updated_rwlock);
HASH_FIND(hh, l_token_item->token_ts_updated, &l_token_update_hash, sizeof(dap_hash_fast_t), l_token_update_item);
pthread_rwlock_unlock(&l_token_item->token_ts_updated_rwlock);
@@ -1493,7 +1493,6 @@ int s_token_add_check(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token_si
DAP_DELETE(l_token);
return DAP_LEDGER_TOKEN_ADD_CHECK_NOT_ENOUGH_UNIQUE_SIGNS;
}
- bool l_legacy_type = a_token_size != l_token_size;
size_t l_signs_approve = 0;
size_t l_verify_size = 0;
uint16_t l_tmp_auth_signs = 0;
@@ -1533,14 +1532,13 @@ int s_token_add_check(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token_si
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
dap_ledger_hal_item_t *l_hash_found = NULL;
if (ret != DAP_LEDGER_CHECK_OK) {
- if (s_hal_items) {
+ if (PVT(a_ledger)->hal_items) {
dap_hash_fast_t l_token_hash;
if (!dap_hash_fast_is_blank(&l_token_update_hash))
l_token_hash = l_token_update_hash;
else
dap_hash_fast(a_token, a_token_size, &l_token_hash);
- HASH_FIND(hh, s_hal_items, &l_token_hash, sizeof(dap_hash_fast_t), l_hash_found);
- debug_if(s_debug_more && l_hash_found, L_MSG, "Datum %s is whitelisted", dap_hash_fast_to_str_static(&l_token_hash));
+ l_hash_found = s_check_hal(a_ledger, &l_token_hash);
}
if (!l_hash_found) {
DAP_DELETE(l_token);
@@ -1727,7 +1725,7 @@ int dap_ledger_token_add(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token
} else {
assert(l_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_UPDATE);
pthread_rwlock_wrlock(&PVT(a_ledger)->tokens_rwlock);
- dap_ledger_token_update_item_t *l_token_update_item;
+ dap_ledger_token_update_item_t *l_token_update_item = NULL;
pthread_rwlock_wrlock(&l_token_item->token_ts_updated_rwlock);
HASH_FIND(hh, l_token_item->token_ts_updated, &l_token_update_hash, sizeof(dap_hash_fast_t), l_token_update_item);
if (l_token_update_item) {
@@ -1779,8 +1777,6 @@ int dap_ledger_token_add(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token
debug_if(s_debug_more, L_INFO, "%s token %s has been %s, total_supply: %s, signs_valid: %zu, signs_total: %zu",
l_type_str, l_token_item->ticker, l_declare_update_str,
l_balance_dbg, l_token_item->auth_signs_valid, l_token_item->auth_signs_total);
-
- s_threshold_emissions_proc(a_ledger); /* TODO process thresholds only for no-consensus chains */
s_ledger_token_cache_update(a_ledger, l_token_item);
return ret;
}
@@ -1988,147 +1984,84 @@ json_object *dap_ledger_token_tx_item_list(dap_ledger_t * a_ledger, dap_chain_ad
return json_arr_out;
}
-json_object *dap_ledger_threshold_info(dap_ledger_t *a_ledger, size_t a_limit, size_t a_offset)
+json_object *dap_ledger_threshold_info(dap_ledger_t *a_ledger, size_t a_limit, size_t a_offset, dap_chain_hash_fast_t *a_threshold_hash)
{
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_tx_item_t *l_tx_item, *l_tx_tmp;
- json_object* json_arr_out = json_object_new_array();
+ dap_ledger_tx_item_t *l_tx_item = NULL, *l_tx_tmp;
+ json_object *json_arr_out = json_object_new_array();
+ if (!json_arr_out)
+ return NULL;
uint32_t l_counter = 0;
- pthread_rwlock_rdlock(&l_ledger_pvt->threshold_txs_rwlock);
size_t l_arr_start = 0;
if (a_offset > 0) {
l_arr_start = a_offset;
- json_object* json_obj_tx = json_object_new_object();
+ json_object *json_obj_tx = json_object_new_object();
+ if (!json_obj_tx) {
+ json_object_put(json_arr_out);
+ return NULL;
+ }
json_object_object_add(json_obj_tx, "offset", json_object_new_int(l_arr_start));
json_object_array_add(json_arr_out, json_obj_tx);
}
- size_t l_arr_end = HASH_COUNT(l_ledger_pvt->threshold_txs);
+ pthread_rwlock_rdlock(&l_ledger_pvt->threshold_txs_rwlock);
+ size_t l_arr_end = l_arr_start + a_limit;
if (a_limit) {
- json_object* json_obj_tx = json_object_new_object();
- json_object_object_add(json_obj_tx, "limit", json_object_new_int(a_limit));
- json_object_array_add(json_arr_out, json_obj_tx);
- l_arr_end = l_arr_start + a_limit;
- if (l_arr_end > HASH_COUNT(l_ledger_pvt->threshold_txs)) {
- l_arr_end = HASH_COUNT(l_ledger_pvt->threshold_txs);
- }
- }
- size_t i_tmp = 0;
- HASH_ITER(hh, l_ledger_pvt->threshold_txs, l_tx_item, l_tx_tmp){
- if (i_tmp < l_arr_start || i_tmp >= l_arr_end) {
- i_tmp++;
- continue;
- }
- i_tmp++;
- json_object* json_obj_tx = json_object_new_object();
+ json_object *json_obj_tx = json_object_new_object();
if (!json_obj_tx) {
+ pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
+ json_object_put(json_arr_out);
return NULL;
}
- char l_tx_prev_hash_str[70]={0};
- char l_time[1024] = {0};
- dap_chain_hash_fast_to_str(&l_tx_item->tx_hash_fast,l_tx_prev_hash_str,sizeof(l_tx_prev_hash_str));
- dap_time_to_str_rfc822(l_time, sizeof(l_time), l_tx_item->tx->header.ts_created);
- //log_it(L_DEBUG,"Ledger thresholded tx_hash_fast %s, time_created: %s, tx_item_size: %d", l_tx_prev_hash_str, l_time, l_tx_item->tx->header.tx_items_size);
- json_object_object_add(json_obj_tx, "Ledger thresholded tx_hash_fast", json_object_new_string(l_tx_prev_hash_str));
- json_object_object_add(json_obj_tx, "time_created", json_object_new_string(l_time));
- json_object_object_add(json_obj_tx, "tx_item_size", json_object_new_int(l_tx_item->tx->header.tx_items_size));
- json_object_array_add(json_arr_out, json_obj_tx);
- l_counter +=1;
- }
- if (!l_counter){
- json_object* json_obj_tx = json_object_new_object();
- json_object_object_add(json_obj_tx, "status", json_object_new_string("0 items in ledger tx threshold"));
- json_object_array_add(json_arr_out, json_obj_tx);
- }
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
-
- pthread_rwlock_rdlock(&l_ledger_pvt->threshold_emissions_rwlock);
- l_counter = 0;
- dap_ledger_token_emission_item_t *l_emission_item, *l_emission_tmp;
- HASH_ITER(hh, l_ledger_pvt->threshold_emissions, l_emission_item, l_emission_tmp){
- json_object* json_obj_tx = json_object_new_object();
- char l_emission_hash_str[70]={0};
- dap_chain_hash_fast_to_str(&l_emission_item->datum_token_emission_hash,l_emission_hash_str,sizeof(l_emission_hash_str));
- //log_it(L_DEBUG,"Ledger thresholded datum_token_emission_hash %s, emission_item_size: %lld", l_emission_hash_str, l_emission_item->datum_token_emission_size);
- json_object_object_add(json_obj_tx, "Ledger thresholded datum_token_emission_hash", json_object_new_string(l_emission_hash_str));
- json_object_object_add(json_obj_tx, "tx_item_size", json_object_new_int(l_tx_item->tx->header.tx_items_size));
- json_object_array_add(json_arr_out, json_obj_tx);
- l_counter +=1;
- }
- if (!l_counter){
- json_object* json_obj_tx = json_object_new_object();
- json_object_object_add(json_obj_tx, "status", json_object_new_string("0 items in ledger emission threshold"));
+ json_object_object_add(json_obj_tx, "limit", json_object_new_int(a_limit));
json_object_array_add(json_arr_out, json_obj_tx);
}
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_emissions_rwlock);
-
- return json_arr_out;
-}
-
-json_object *dap_ledger_threshold_hash_info(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *l_threshold_hash, size_t a_limit, size_t a_offset)
-{
- dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_tx_item_t *l_tx_item, *l_tx_tmp;
- json_object * json_arr_out = json_object_new_array();
- json_object* json_obj_tx = json_object_new_object();
- if (!json_obj_tx) {
- return NULL;
- }
- size_t l_arr_start = 0;
- if (a_offset > 0) {
- l_arr_start = a_offset;
- json_object* json_obj_tx = json_object_new_object();
- json_object_object_add(json_obj_tx, "offset", json_object_new_int(l_arr_start));
- json_object_array_add(json_arr_out, json_obj_tx);
+ if (l_arr_end > HASH_COUNT(l_ledger_pvt->threshold_txs)) {
+ l_arr_end = HASH_COUNT(l_ledger_pvt->threshold_txs);
}
- size_t l_arr_end = HASH_COUNT(l_ledger_pvt->threshold_txs);
- if (a_limit) {
- json_object* json_obj_tx = json_object_new_object();
- json_object_object_add(json_obj_tx, "limit", json_object_new_int(l_arr_start));
- json_object_array_add(json_arr_out, json_obj_tx);
- l_arr_end = l_arr_start + a_limit;
- if (l_arr_end > HASH_COUNT(l_ledger_pvt->threshold_txs)) {
- l_arr_end = HASH_COUNT(l_ledger_pvt->threshold_txs);
+ if (a_threshold_hash) {
+ json_object *json_obj_tx = json_object_new_object();
+ if (!json_obj_tx) {
+ pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
+ json_object_put(json_arr_out);
+ return NULL;
}
- }
- size_t i_tmp = 0;
- pthread_rwlock_rdlock(&l_ledger_pvt->threshold_txs_rwlock);
- HASH_ITER(hh, l_ledger_pvt->threshold_txs, l_tx_item, l_tx_tmp){
- if (!memcmp(l_threshold_hash, &l_tx_item->tx_hash_fast, sizeof(dap_chain_hash_fast_t))){
- if (i_tmp < l_arr_start || i_tmp >= l_arr_end) {
- i_tmp++;
- continue;
- }
- i_tmp++;
- char l_tx_hash_str[70]={0};
- dap_chain_hash_fast_to_str(l_threshold_hash,l_tx_hash_str,sizeof(l_tx_hash_str));
- json_object_object_add(json_obj_tx, "Hash was found in ledger tx threshold", json_object_new_string(l_tx_hash_str));
+ HASH_FIND(hh, l_ledger_pvt->threshold_txs, a_threshold_hash, sizeof(dap_hash_t), l_tx_item);
+ if (l_tx_item) {
+ json_object_object_add(json_obj_tx, "Hash was found in ledger tx threshold", json_object_new_string(dap_hash_fast_to_str_static(a_threshold_hash)));
+ json_object_array_add(json_arr_out, json_obj_tx);
+ } else {
+ json_object_object_add(json_obj_tx, "Hash wasn't found in ledger", json_object_new_string("empty"));
json_object_array_add(json_arr_out, json_obj_tx);
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
- return json_arr_out;
}
- }
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
-
- pthread_rwlock_rdlock(&l_ledger_pvt->threshold_emissions_rwlock);
- dap_ledger_token_emission_item_t *l_emission_item, *l_emission_tmp;
- HASH_ITER(hh, l_ledger_pvt->threshold_emissions, l_emission_item, l_emission_tmp){
- if (!memcmp(&l_emission_item->datum_token_emission_hash,l_threshold_hash, sizeof(dap_chain_hash_fast_t))){
- if (i_tmp < l_arr_start || i_tmp >= l_arr_end) {
- i_tmp++;
+ } else {
+ size_t i_tmp = 0;
+ HASH_ITER(hh, l_ledger_pvt->threshold_txs, l_tx_item, l_tx_tmp) {
+ if (i_tmp < l_arr_start || i_tmp++ >= l_arr_end)
continue;
- }
- i_tmp++;
- char l_emission_hash_str[70]={0};
- dap_chain_hash_fast_to_str(l_threshold_hash,l_emission_hash_str,sizeof(l_emission_hash_str));
- json_object_object_add(json_obj_tx, "Hash was found in ledger emission threshold", json_object_new_string(l_emission_hash_str));
+ json_object *json_obj_tx = json_object_new_object();
+ if (!json_obj_tx) {
+ pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
+ json_object_put(json_arr_out);
+ return NULL;
+ }
+ char l_tx_prev_hash_str[DAP_HASH_FAST_STR_SIZE]={0};
+ char l_time[DAP_TIME_STR_SIZE] = {0};
+ dap_chain_hash_fast_to_str(&l_tx_item->tx_hash_fast,l_tx_prev_hash_str,sizeof(l_tx_prev_hash_str));
+ dap_time_to_str_rfc822(l_time, sizeof(l_time), l_tx_item->cache_data.ts_created);
+ json_object_object_add(json_obj_tx, "Ledger thresholded tx_hash_fast", json_object_new_string(l_tx_prev_hash_str));
+ json_object_object_add(json_obj_tx, "time_created", json_object_new_string(l_time));
+ json_object_object_add(json_obj_tx, "tx_item_size", json_object_new_int(l_tx_item->tx->header.tx_items_size));
+ json_object_array_add(json_arr_out, json_obj_tx);
+ l_counter++;
+ }
+ if (!l_counter) {
+ json_object* json_obj_tx = json_object_new_object();
+ json_object_object_add(json_obj_tx, "status", json_object_new_string("0 items in ledger tx threshold"));
json_object_array_add(json_arr_out, json_obj_tx);
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
- return json_arr_out;
}
+ pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
}
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_emissions_rwlock);
- json_object_object_add(json_obj_tx, "Hash wasn't found in ledger", json_object_new_string("empty"));
- json_object_array_add(json_arr_out, json_obj_tx);
+
return json_arr_out;
}
@@ -2253,7 +2186,7 @@ json_object *s_token_item_to_json(dap_ledger_token_item_t *a_token_item)
json_object_object_add(json_obj_datum, "-->Token name", json_object_new_string(a_token_item->ticker));
json_object_object_add(json_obj_datum, "type", json_object_new_string(l_type_str));
if (a_token_item->subtype != DAP_CHAIN_DATUM_TOKEN_SUBTYPE_SIMPLE && a_token_item->subtype != DAP_CHAIN_DATUM_TOKEN_SUBTYPE_PUBLIC) {
- json_object_object_add(json_obj_datum, "flags", json_object_new_string(s_flag_str_from_code(a_token_item->datum_token->header_native_decl.flags)));
+ dap_chain_datum_token_flags_dump_to_json(json_obj_datum, a_token_item->datum_token->header_native_decl.flags);
json_object_object_add(json_obj_datum, "description", a_token_item->description ?
json_object_new_string(a_token_item->description) :
json_object_new_string("The token description is not set"));
@@ -2272,7 +2205,7 @@ 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_object_add(json_obj_datum, "Signature public keys", l_json_arr_pkeys);
+ json_object_object_add(json_obj_datum, "Signatures public keys", l_json_arr_pkeys);
json_object_object_add(json_obj_datum, "Total emissions", json_object_new_int(HASH_COUNT(a_token_item->token_emissions)));
return json_obj_datum;
}
@@ -2325,15 +2258,13 @@ json_object *dap_ledger_token_info(dap_ledger_t *a_ledger, size_t a_limit, size_
* @param a_token_ticker
* @return
*/
-json_object *dap_ledger_token_info_by_name(dap_ledger_t *a_ledger, const char *a_token_ticker) {
- json_object *l_jobj = NULL;
+json_object *dap_ledger_token_info_by_name(dap_ledger_t *a_ledger, const char *a_token_ticker)
+{
dap_ledger_token_item_t *l_token_item = NULL;
HASH_FIND_STR(PVT(a_ledger)->tokens, a_token_ticker, l_token_item);
- if (l_token_item) {
+ if (l_token_item)
return s_token_item_to_json(l_token_item);
- } else {
- return json_object_new_null();
- }
+ return json_object_new_null();
}
/**
@@ -2356,34 +2287,6 @@ dap_list_t* dap_ledger_token_decl_all(dap_ledger_t *a_ledger)
}
-/**
- * @brief s_threshold_emissions_proc
- * @param a_ledger
- */
-static void s_threshold_emissions_proc(dap_ledger_t * a_ledger)
-{
- bool l_success;
- do {
- l_success = false;
- dap_ledger_token_emission_item_t *l_emission_item, *l_emission_tmp;
- pthread_rwlock_wrlock(&PVT(a_ledger)->threshold_emissions_rwlock);
- HASH_ITER(hh, PVT(a_ledger)->threshold_emissions, l_emission_item, l_emission_tmp) {
- int l_res = dap_ledger_token_emission_add(a_ledger, (byte_t *)l_emission_item->datum_token_emission,
- l_emission_item->datum_token_emission_size,
- &l_emission_item->datum_token_emission_hash, true);
- if (l_res != DAP_CHAIN_CS_VERIFY_CODE_NO_DECREE) {
- HASH_DEL(PVT(a_ledger)->threshold_emissions, l_emission_item);
- if (l_res)
- DAP_DELETE(l_emission_item->datum_token_emission);
- DAP_DELETE(l_emission_item);
- l_success = true;
- }
-
- }
- pthread_rwlock_unlock(&PVT(a_ledger)->threshold_emissions_rwlock);
- } while (l_success);
-}
-
/**
* @brief s_threshold_txs_proc
* @param a_ledger
@@ -2415,7 +2318,8 @@ static void s_threshold_txs_proc( dap_ledger_t *a_ledger)
* @breif s_treshold_txs_free
* @param a_ledger
*/
-static void s_threshold_txs_free(dap_ledger_t *a_ledger){
+static void s_threshold_txs_free(dap_ledger_t *a_ledger)
+{
log_it(L_DEBUG, "Start free threshold txs");
dap_ledger_private_t *l_pvt = PVT(a_ledger);
dap_ledger_tx_item_t *l_current = NULL, *l_tmp = NULL;
@@ -2435,29 +2339,6 @@ static void s_threshold_txs_free(dap_ledger_t *a_ledger){
pthread_rwlock_unlock(&l_pvt->threshold_txs_rwlock);
}
-/**
- * @breif s_treshold_emission_free
- * @param a_ledger
- */
-static void s_threshold_emission_free(dap_ledger_t *a_ledger){
- log_it(L_DEBUG, "Start free threshold emission");
- dap_ledger_private_t *l_pvt = PVT(a_ledger);
- dap_ledger_token_emission_item_t *l_current = NULL, *l_tmp = NULL;
- dap_nanotime_t l_time_cut_off = dap_nanotime_now() - dap_nanotime_from_sec(7200); //7200 sec = 2 hours.
- pthread_rwlock_wrlock(&l_pvt->threshold_emissions_rwlock);
- HASH_ITER(hh, l_pvt->threshold_emissions, l_current, l_tmp) {
- if (l_current->ts_added < l_time_cut_off) {
- char l_token_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_chain_hash_fast_to_str(&l_current->datum_token_emission_hash, l_token_hash_str, sizeof(l_token_hash_str));
- HASH_DEL(l_pvt->threshold_emissions, l_current);
- DAP_DELETE(l_current->datum_token_emission);
- log_it(L_NOTICE, "Removed token emission %s form threshold ledger", l_token_hash_str);
- }
- }
- pthread_rwlock_unlock(&l_pvt->threshold_emissions_rwlock);
-}
-
-
/**
* @brief s_load_cache_gdb_loaded_balances_callback
* @param a_global_db_context
@@ -2722,6 +2603,10 @@ dap_ledger_t *dap_ledger_create(dap_chain_net_t *a_net, uint16_t a_flags)
l_ledger_pvt->check_token_emission = a_flags & DAP_LEDGER_CHECK_TOKEN_EMISSION;
l_ledger_pvt->cached = a_flags & DAP_LEDGER_CACHE_ENABLED;
l_ledger_pvt->mapped = a_flags & DAP_LEDGER_MAPPED;
+ l_ledger_pvt->threshold_enabled = a_flags & DAP_LEDGER_THRESHOLD_ENABLED;
+ if (l_ledger_pvt->threshold_enabled)
+ l_ledger_pvt->threshold_txs_free_timer = dap_interval_timer_create(s_threshold_free_timer_tick,
+ (dap_timer_callback_t)s_threshold_txs_free, l_ledger);
pthread_cond_init(&l_ledger_pvt->load_cond, NULL);
pthread_mutex_init(&l_ledger_pvt->load_mutex, NULL);
@@ -2755,7 +2640,7 @@ dap_ledger_t *dap_ledger_create(dap_chain_net_t *a_net, uint16_t a_flags)
return NULL;
}
dap_chain_hash_fast_from_str(l_whitelist[i], &l_hal_item->hash);
- HASH_ADD(hh, s_hal_items, hash, sizeof(l_hal_item->hash), l_hal_item);
+ HASH_ADD(hh, l_ledger_pvt->hal_items, hash, sizeof(l_hal_item->hash), l_hal_item);
}
dap_config_close(l_cfg);
log_it(L_DEBUG, "HAL items count for chain %s : %d", l_entry_name, l_whitelist_size);
@@ -2816,7 +2701,7 @@ static bool s_ledger_permissions_check(dap_ledger_token_item_t *a_token_item, en
return false;
}
-int s_ledger_addr_check(dap_ledger_token_item_t *a_token_item, dap_chain_addr_t *a_addr, bool a_receive)
+dap_ledger_check_error_t s_ledger_addr_check(dap_ledger_token_item_t *a_token_item, dap_chain_addr_t *a_addr, bool a_receive)
{
dap_return_val_if_fail(a_token_item && a_addr, DAP_LEDGER_CHECK_INVALID_ARGS);
if (dap_chain_addr_is_blank(a_addr))
@@ -2849,134 +2734,148 @@ int s_ledger_addr_check(dap_ledger_token_item_t *a_token_item, dap_chain_addr_t
return DAP_LEDGER_CHECK_OK;
}
-int dap_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size, dap_chain_hash_fast_t *a_emission_hash)
+int s_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size, dap_chain_hash_fast_t *a_emission_hash,
+ dap_chain_datum_token_emission_t **a_emission, dap_ledger_token_item_t **a_token_item)
{
dap_return_val_if_fail(a_token_emission && a_token_emission_size, DAP_LEDGER_CHECK_INVALID_ARGS);
-
- int l_ret = DAP_LEDGER_CHECK_OK;
- dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- const char *l_token_ticker = ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.ticker;
- dap_ledger_token_item_t *l_token_item = s_ledger_find_token(a_ledger, l_token_ticker);
+ size_t l_emission_size = a_token_emission_size;
+ dap_chain_datum_token_emission_t *l_emission = dap_chain_datum_emission_read(a_token_emission, &l_emission_size);
+ if (!l_emission)
+ return DAP_LEDGER_CHECK_INVALID_SIZE;
+ if (l_emission->hdr.version < 3 && !a_token_item) { // It's mempool check
+ log_it(L_WARNING, "Legacy emission version %hhu isn't supported for a new emissions", l_emission->hdr.version);
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_EMISSION_CHECK_LEGACY_FORBIDDEN;
+ }
+ dap_ledger_token_item_t *l_token_item = s_ledger_find_token(a_ledger, l_emission->hdr.ticker);
if (!l_token_item) {
- log_it(L_ERROR, "Check emission: token %s was not found", l_token_ticker);
+ log_it(L_ERROR, "Check emission: token %s was not found", l_emission->hdr.ticker);
+ DAP_DELETE(l_emission);
return DAP_LEDGER_CHECK_TICKER_NOT_FOUND;
}
-
- dap_ledger_token_emission_item_t * l_token_emission_item = NULL;
+ dap_ledger_token_emission_item_t *l_token_emission_item = NULL;
// check if such emission is already present in table
- pthread_rwlock_rdlock(l_token_item ? &l_token_item->token_emissions_rwlock
- : &l_ledger_pvt->threshold_emissions_rwlock);
- HASH_FIND(hh,l_token_item ? l_token_item->token_emissions : l_ledger_pvt->threshold_emissions,
- a_emission_hash, sizeof(*a_emission_hash), l_token_emission_item);
- unsigned long long l_threshold_emissions_count = HASH_COUNT( l_ledger_pvt->threshold_emissions);
- pthread_rwlock_unlock(l_token_item ? &l_token_item->token_emissions_rwlock
- : &l_ledger_pvt->threshold_emissions_rwlock);
+ pthread_rwlock_rdlock(&l_token_item->token_emissions_rwlock);
+ HASH_FIND(hh, l_token_item->token_emissions, a_emission_hash, sizeof(*a_emission_hash), l_token_emission_item);
+ pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
if (l_token_emission_item) {
- debug_if(s_debug_more, L_ERROR, "Can't add token emission datum of %s %s ( %s ): already present in cache",
- dap_uint256_to_char(l_token_emission_item->datum_token_emission->hdr.version >= 2
- ? l_token_emission_item->datum_token_emission->hdr.value
- : GET_256_FROM_64(l_token_emission_item->datum_token_emission->hdr.value64),
- NULL),
- l_token_ticker, dap_chain_hash_fast_to_str_static(a_emission_hash));
- l_ret = DAP_LEDGER_CHECK_ALREADY_CACHED;
- } else if ( (! l_token_item) && ( l_threshold_emissions_count >= s_threshold_emissions_max)) {
- debug_if(s_debug_more, L_WARNING, "Emissions threshold overflow, max %zu items", s_threshold_emissions_max);
- l_ret = DAP_LEDGER_EMISSION_CHECK_THRESHOLD_OVERFLOW;
- }
- if (l_ret || !PVT(a_ledger)->check_token_emission)
- return l_ret;
-
- if (s_hal_items) {
- dap_ledger_hal_item_t *l_hash_found = NULL;
- HASH_FIND(hh, s_hal_items, a_emission_hash, sizeof(*a_emission_hash), l_hash_found);
- if (l_hash_found) {
- char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE] = { '\0' };
- dap_chain_hash_fast_to_str(a_emission_hash, l_hash_str, sizeof(l_hash_str));
- debug_if(s_debug_more, L_MSG, "Datum %s is whitelisted", l_hash_str);
- return l_ret;
- }
+ 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_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_ALREADY_CACHED;
}
- // Check emission correctness
- size_t l_emission_size = a_token_emission_size;
- dap_chain_datum_token_emission_t *l_emission = dap_chain_datum_emission_read(a_token_emission, &l_emission_size);
+ if (!PVT(a_ledger)->check_token_emission)
+ goto ret_success;
+ // Check emission correctness
if (IS_ZERO_256((l_emission->hdr.value))) {
log_it(L_ERROR, "Emission check: zero %s emission value", l_token_item->ticker);
DAP_DELETE(l_emission);
return DAP_LEDGER_CHECK_ZERO_VALUE;
}
- if (!s_ledger_token_supply_check(l_token_item, l_emission->hdr.value))
+ if (!s_ledger_token_supply_check(l_token_item, l_emission->hdr.value)) {
+ DAP_DELETE(l_emission);
return DAP_LEDGER_EMISSION_CHECK_VALUE_EXCEEDS_CURRENT_SUPPLY;
+ }
//additional check for private tokens
if((l_token_item->subtype == DAP_CHAIN_DATUM_TOKEN_SUBTYPE_PRIVATE)
|| (l_token_item->subtype == DAP_CHAIN_DATUM_TOKEN_SUBTYPE_NATIVE)) {
- if ((l_ret = s_ledger_addr_check(l_token_item, &((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.address, true))) {
+ dap_ledger_check_error_t ret = s_ledger_addr_check(l_token_item, &l_emission->hdr.address, true);
+ if (ret == DAP_LEDGER_CHECK_ADDR_FORBIDDEN) {
log_it(L_WARNING, "Address %s is not in allowed to receive for emission of token %s",
- dap_chain_addr_to_str(&((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.address), l_token_item->ticker);
+ dap_chain_addr_to_str(&l_emission->hdr.address), l_token_item->ticker);
DAP_DELETE(l_emission);
- return l_ret;
- }
- }
- switch (l_emission->hdr.type){
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:{
- dap_ledger_token_item_t *l_token_item = s_ledger_find_token(a_ledger, l_emission->hdr.ticker);
- if (l_token_item) {
- dap_sign_t *l_sign = (dap_sign_t *)(l_emission->tsd_n_signs + l_emission->data.type_auth.tsd_total_size);
- size_t l_offset = (byte_t *)l_sign - (byte_t *)l_emission;
- uint16_t l_aproves = 0, l_aproves_valid = l_token_item->auth_signs_valid;
- size_t l_sign_data_check_size = sizeof(l_emission->hdr);
- size_t l_sign_auth_count = l_emission->data.type_auth.signs_count;
- size_t l_sign_auth_size = l_emission->data.type_auth.size;
- void *l_emi_ptr_check_size = &l_emission->hdr;
- if (l_emission->hdr.version == 3) {
- l_sign_data_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_total_size;
- l_emission->data.type_auth.signs_count = 0;
- l_emission->data.type_auth.size = 0;
- l_emi_ptr_check_size = l_emission;
- }
- for (uint16_t i = 0; i < l_sign_auth_count && l_offset < l_emission_size; i++) {
- if (dap_sign_verify_size(l_sign, l_emission_size - l_offset)) {
- // Find pkey in auth pkeys
- for (uint16_t k = 0; k < l_token_item->auth_signs_total; k++) {
- if (dap_pkey_compare_with_sign(l_token_item->auth_pkeys[k], l_sign)) {
- // Verify if token emission is signed
- if (!dap_sign_verify(l_sign, l_emi_ptr_check_size, l_sign_data_check_size))
- l_aproves++;
- break;
- }
- }
- size_t l_sign_size = dap_sign_get_size(l_sign);
- l_offset += l_sign_size;
- l_sign = (dap_sign_t *)((byte_t *)l_emission + l_offset);
- } else
- break;
- }
- if (l_emission->hdr.version == 3) {
- l_emission->data.type_auth.signs_count = l_sign_auth_count;
- l_emission->data.type_auth.size = l_sign_auth_size;
- }
- if (l_aproves < l_aproves_valid ){
- debug_if(s_debug_more, L_WARNING, "Emission of %s datoshi of %s:%s is wrong: only %u valid aproves when %u need",
- dap_uint256_to_char(l_emission->hdr.value, NULL), a_ledger->net->pub.name, l_emission->hdr.ticker,
- l_aproves, l_aproves_valid);
- l_ret = DAP_LEDGER_CHECK_NOT_ENOUGH_VALID_SIGNS;
- char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE] = { '\0' };
- dap_chain_hash_fast_to_str(a_emission_hash, l_hash_str, sizeof(l_hash_str));
- log_it(L_MSG, "!!! Datum hash for HAL: %s", l_hash_str);
+ return ret;
+ }
+ }
+ switch (l_emission->hdr.type) {
+
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH: {
+ size_t l_sign_data_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_total_size;
+ if (l_sign_data_check_size > l_emission_size) {
+ if (!s_check_hal(a_ledger, a_emission_hash)) {
+ log_it(L_WARNING, "Incorrect size %zu of datum emission, expected at least %zu", l_emission_size, l_sign_data_check_size);
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_INVALID_SIZE;
+ }
+ goto ret_success;
+ }
+ size_t l_emission_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_n_signs_size;
+ if (l_emission_check_size != l_emission_size) {
+ log_it(L_WARNING, "Incorrect size %zu of datum emission, must be %zu", l_emission_size, l_emission_check_size);
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_INVALID_SIZE;
+ }
+ size_t l_signs_unique = l_emission->data.type_auth.signs_count;
+ dap_sign_t **l_signs = dap_sign_get_unique_signs(l_emission->tsd_n_signs + l_emission->data.type_auth.tsd_total_size,
+ l_emission->data.type_auth.tsd_n_signs_size, &l_signs_unique);
+ if (l_signs_unique < l_token_item->auth_signs_valid) {
+ if (!s_check_hal(a_ledger, a_emission_hash)) {
+ DAP_DEL_Z(l_signs);
+ log_it(L_WARNING, "The number of unique token signs %zu is less than total token signs set to %zu",
+ l_signs_unique, l_token_item->auth_signs_total);
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_NOT_ENOUGH_VALID_SIGNS;
+ }
+ goto ret_success;
+ }
+ size_t l_sign_auth_count = l_emission->data.type_auth.signs_count;
+ size_t l_sign_auth_size = l_emission->data.type_auth.tsd_n_signs_size;
+ if (l_emission->hdr.version < 3) {
+ l_sign_data_check_size = sizeof(l_emission->hdr);
+ } else {
+ l_emission->data.type_auth.signs_count = 0;
+ l_emission->data.type_auth.tsd_n_signs_size = 0;
+ }
+ size_t l_aproves = 0;
+ for (uint16_t i = 0; i < l_signs_unique; i++) {
+ for (uint16_t k = 0; k < l_token_item->auth_signs_total; k++) {
+ if (dap_pkey_compare_with_sign(l_token_item->auth_pkeys[k], l_signs[i])) {
+ // Verify if token emission is signed
+ if (!dap_sign_verify(l_signs[i], l_emission, l_sign_data_check_size))
+ l_aproves++;
+ break;
}
- }else{
- debug_if(s_debug_more, L_WARNING, "Can't find token declaration %s:%s thats pointed in token emission datum",
- a_ledger->net->pub.name, l_emission->hdr.ticker);
- l_ret = DAP_LEDGER_CHECK_TICKER_NOT_FOUND;
}
- }break;
- default:{}
+ }
+ if (l_emission->hdr.version >= 3) {
+ l_emission->data.type_auth.signs_count = l_sign_auth_count;
+ l_emission->data.type_auth.tsd_n_signs_size = l_sign_auth_size;
+ }
+ DAP_DELETE(l_signs);
+ if (l_aproves < l_token_item->auth_signs_valid &&
+ !s_check_hal(a_ledger, a_emission_hash)) {
+ log_it(L_WARNING, "Emission of %s datoshi of %s:%s is wrong: only %zu valid aproves when %zu need",
+ dap_uint256_to_char(l_emission->hdr.value, NULL), a_ledger->net->pub.name, l_emission->hdr.ticker,
+ l_aproves, l_token_item->auth_signs_valid);
+ debug_if(s_debug_more, L_ATT, "!!! Datum hash for HAL: %s", dap_chain_hash_fast_to_str_static(a_emission_hash));
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_NOT_ENOUGH_VALID_SIGNS;
+ }
+ } break;
+
+ default:
+ log_it(L_ERROR, "Checking emission of type %s not implemented", dap_chain_datum_emission_type_str(l_emission->hdr.type));
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_PARSE_ERROR;
}
- DAP_DELETE(l_emission);
- return l_ret;
+
+ret_success:
+ if (a_token_item)
+ *a_token_item = l_token_item;
+ if (a_emission)
+ *a_emission = l_emission;
+ else
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_OK;
+}
+
+int dap_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size, dap_chain_hash_fast_t *a_emission_hash)
+{
+ return s_emission_add_check(a_ledger, a_token_emission, a_token_emission_size, a_emission_hash, NULL, NULL);
}
static void s_ledger_emission_cache_update(dap_ledger_t *a_ledger, dap_ledger_token_emission_item_t *a_emission_item)
@@ -3003,132 +2902,54 @@ static void s_ledger_emission_cache_update(dap_ledger_t *a_ledger, dap_ledger_to
* @return
*/
-int dap_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size,
- dap_hash_fast_t *a_emission_hash, bool a_from_threshold)
+int dap_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size, dap_hash_fast_t *a_emission_hash)
{
- dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_token_emission_item_t * l_token_emission_item = NULL;
- int l_ret = dap_ledger_token_emission_add_check(a_ledger, a_token_emission, a_token_emission_size, a_emission_hash);
- if (l_ret) {
- if (l_ret == DAP_CHAIN_CS_VERIFY_CODE_NO_DECREE) { // TODO remove emissions threshold
- if (HASH_COUNT(l_ledger_pvt->threshold_emissions) < s_threshold_emissions_max) {
- l_token_emission_item = DAP_NEW_Z(dap_ledger_token_emission_item_t);
- if ( !l_token_emission_item ) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return DAP_LEDGER_CHECK_NOT_ENOUGH_MEMORY;
- }
- l_token_emission_item->datum_token_emission = DAP_DUP_SIZE(a_token_emission, a_token_emission_size);
- if ( !l_token_emission_item->datum_token_emission ) {
- DAP_DELETE(l_token_emission_item);
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return DAP_LEDGER_CHECK_NOT_ENOUGH_MEMORY;
- }
- l_token_emission_item->datum_token_emission_size = a_token_emission_size;
- dap_hash_fast_t l_emi_hash = {0};
- dap_hash_fast(a_token_emission, a_token_emission_size, &l_emi_hash);
- pthread_rwlock_wrlock(&l_ledger_pvt->threshold_emissions_rwlock);
- l_token_emission_item->datum_token_emission_hash = l_emi_hash;
- l_token_emission_item->ts_added = dap_nanotime_now();
- HASH_ADD(hh, l_ledger_pvt->threshold_emissions, datum_token_emission_hash,
- sizeof(*a_emission_hash), l_token_emission_item);
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_emissions_rwlock);
- } else {
- if(s_debug_more)
- log_it(L_WARNING,"threshold for emissions is overfulled (%zu max), dropping down new data, added nothing",
- s_threshold_emissions_max);
- }
- }
+ dap_ledger_token_item_t *l_token_item = NULL;
+ dap_chain_datum_token_emission_t *l_emission = NULL;
+ int l_ret = s_emission_add_check(a_ledger, a_token_emission, a_token_emission_size, a_emission_hash, &l_emission, &l_token_item);
+ if (l_ret != DAP_LEDGER_CHECK_OK)
return l_ret;
- }
- const char *c_token_ticker = ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.ticker;
- dap_ledger_token_item_t *l_token_item = s_ledger_find_token(a_ledger, c_token_ticker);
- if (!l_token_item && a_from_threshold)
- return DAP_LEDGER_CHECK_TICKER_NOT_FOUND;
-
+ dap_ledger_token_emission_item_t *l_token_emission_item = NULL;
// check if such emission is already present in table
- pthread_rwlock_rdlock( l_token_item ? &l_token_item->token_emissions_rwlock
- : &l_ledger_pvt->threshold_emissions_rwlock);
- HASH_FIND(hh,l_token_item ? l_token_item->token_emissions : l_ledger_pvt->threshold_emissions,
- a_emission_hash, sizeof(*a_emission_hash), l_token_emission_item);
- pthread_rwlock_unlock(l_token_item ? &l_token_item->token_emissions_rwlock
- : &l_ledger_pvt->threshold_emissions_rwlock);
+ pthread_rwlock_wrlock(&l_token_item->token_emissions_rwlock);
+ HASH_FIND(hh, l_token_item->token_emissions, a_emission_hash, sizeof(*a_emission_hash), l_token_emission_item);
+ if (l_token_emission_item) {
+ pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
+ log_it(L_ERROR, "Duplicate token emission datum of %s %s ( %s )",
+ dap_uint256_to_char(l_emission->hdr.value, NULL), l_emission->hdr.ticker, dap_hash_fast_to_str_static(a_emission_hash));
+ DAP_DELETE(l_emission);
+ return DAP_LEDGER_CHECK_APPLY_ERROR;
+ }
+ l_token_emission_item = DAP_NEW_Z(dap_ledger_token_emission_item_t);
if (!l_token_emission_item) {
- l_token_emission_item = DAP_NEW_Z(dap_ledger_token_emission_item_t);
- if ( !l_token_emission_item ) {
- log_it(L_CRITICAL, "%s", c_error_memory_alloc);
- return DAP_LEDGER_CHECK_NOT_ENOUGH_MEMORY;
- }
- l_token_emission_item->datum_token_emission_size = a_token_emission_size;
- l_token_emission_item->datum_token_emission_hash = *a_emission_hash;
- if (l_token_item) {
- l_token_emission_item->datum_token_emission = dap_chain_datum_emission_read(a_token_emission,
- &l_token_emission_item->datum_token_emission_size);
- //Update value in ledger memory object
- if (!s_ledger_token_supply_check_update(a_ledger, l_token_item,
- l_token_emission_item->datum_token_emission->hdr.value, false)) {
- DAP_DELETE(l_token_emission_item->datum_token_emission);
- DAP_DELETE(l_token_emission_item);
- return DAP_LEDGER_EMISSION_CHECK_VALUE_EXCEEDS_CURRENT_SUPPLY;
- }
-
- pthread_rwlock_wrlock(&l_token_item->token_emissions_rwlock);
- HASH_ADD(hh, l_token_item->token_emissions, datum_token_emission_hash,
- sizeof(*a_emission_hash), l_token_emission_item);
- pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
- // Add it to cache
- s_ledger_emission_cache_update(a_ledger, l_token_emission_item);
- if (s_debug_more) {
- const char *l_balance; dap_uint256_to_char(l_token_emission_item->datum_token_emission->hdr.value, &l_balance);
- log_it(L_NOTICE, "Added token emission datum to emissions cache: type=%s value=%s token=%s to_addr=%s ",
- c_dap_chain_datum_token_emission_type_str[l_token_emission_item->datum_token_emission->hdr.type],
- l_balance, c_token_ticker,
- dap_chain_addr_to_str(&(l_token_emission_item->datum_token_emission->hdr.address)));
- }
- s_threshold_txs_proc(a_ledger);
- } else if (HASH_COUNT(l_ledger_pvt->threshold_emissions) < s_threshold_emissions_max) {
- l_token_emission_item->datum_token_emission = DAP_DUP_SIZE(a_token_emission, a_token_emission_size);
- l_token_emission_item->datum_token_emission_size = a_token_emission_size;
- pthread_rwlock_wrlock(&l_ledger_pvt->threshold_emissions_rwlock);
- l_token_emission_item->ts_added = dap_nanotime_now();
- dap_chain_hash_fast_t l_emi_hash = {0};
- dap_hash_fast(a_token_emission, a_token_emission_size, &l_emi_hash);
- l_token_emission_item->datum_token_emission_hash = l_emi_hash;
- HASH_ADD(hh, l_ledger_pvt->threshold_emissions, datum_token_emission_hash,
- sizeof(*a_emission_hash), l_token_emission_item);
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_emissions_rwlock);
- l_ret = DAP_LEDGER_EMISSION_CHECK_THRESHOLDED;
- if (s_debug_more) {
- const char *l_balance; dap_uint256_to_char(l_token_emission_item->datum_token_emission->hdr.value, &l_balance);
- log_it(L_NOTICE, "Added token emission datum to emissions threshold: type=%s value=%s token=%s to_addr=%s ",
- c_dap_chain_datum_token_emission_type_str[l_token_emission_item->datum_token_emission->hdr.type],
- l_balance, c_token_ticker,
- dap_chain_addr_to_str(&(l_token_emission_item->datum_token_emission->hdr.address)));
- }
- } else {
- DAP_DELETE(l_token_emission_item->datum_token_emission);
- DAP_DELETE(l_token_emission_item);
- if(s_debug_more)
- log_it(L_WARNING,"threshold for emissions is overfulled (%zu max), dropping down new data, added nothing",
- s_threshold_emissions_max);
- l_ret = DAP_LEDGER_EMISSION_CHECK_THRESHOLD_OVERFLOW;
- }
- } else {
- if (l_token_item) {
- if(s_debug_more) {
- char l_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_chain_hash_fast_to_str(a_emission_hash, l_hash_str, sizeof(l_hash_str));
- if ( ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.version == 2 ) {
- log_it(L_ERROR, "Duplicate token emission datum of %s %s ( %s )",
- dap_uint256_to_char(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value, NULL),
- c_token_ticker, l_hash_str);
- } else
- log_it(L_ERROR, "Duplicate token emission datum of %"DAP_UINT64_FORMAT_U" %s ( %s )",
- ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value64, c_token_ticker, l_hash_str);
- }
- }
- l_ret = DAP_LEDGER_CHECK_ALREADY_CACHED;
+ pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+ return DAP_LEDGER_CHECK_NOT_ENOUGH_MEMORY;
+ }
+ l_token_emission_item->datum_token_emission = l_emission;
+ l_token_emission_item->datum_token_emission_hash = *a_emission_hash;
+ HASH_ADD(hh, l_token_item->token_emissions, datum_token_emission_hash, sizeof(*a_emission_hash), l_token_emission_item);
+ //Update value in ledger memory object
+ if (!s_ledger_token_supply_check_update(a_ledger, l_token_item, l_emission->hdr.value, false)) {
+ HASH_DEL(l_token_item->token_emissions, l_token_emission_item);
+ pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
+ DAP_DELETE(l_emission);
+ DAP_DELETE(l_token_emission_item);
+ return DAP_LEDGER_CHECK_APPLY_ERROR;
}
- return l_ret;
+ pthread_rwlock_unlock(&l_token_item->token_emissions_rwlock);
+ // Add it to cache
+ s_ledger_emission_cache_update(a_ledger, l_token_emission_item);
+ if (s_debug_more) {
+ const char *l_balance; dap_uint256_to_char(l_token_emission_item->datum_token_emission->hdr.value, &l_balance);
+ log_it(L_NOTICE, "Added token emission datum to emissions cache: type=%s value=%s token=%s to_addr=%s",
+ dap_chain_datum_emission_type_str(l_emission->hdr.type),
+ l_balance, l_emission->hdr.ticker,
+ dap_chain_addr_to_str(&(l_emission->hdr.address)));
+ }
+ if (PVT(a_ledger)->threshold_enabled)
+ s_threshold_txs_proc(a_ledger);
+ return DAP_LEDGER_CHECK_OK;
}
void s_ledger_stake_lock_cache_update(dap_ledger_t *a_ledger, dap_ledger_stake_lock_item_t *a_stake_lock_item)
@@ -3146,7 +2967,7 @@ void s_ledger_stake_lock_cache_update(dap_ledger_t *a_ledger, dap_ledger_stake_l
int dap_ledger_emission_for_stake_lock_item_add(dap_ledger_t *a_ledger, const dap_chain_hash_fast_t *a_tx_hash)
{
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_stake_lock_item_t *l_new_stake_lock_emission;
+ dap_ledger_stake_lock_item_t *l_new_stake_lock_emission = NULL;
pthread_rwlock_rdlock(&l_ledger_pvt->stake_lock_rwlock);
HASH_FIND(hh, l_ledger_pvt->emissions_for_stake_lock, a_tx_hash, sizeof(dap_hash_fast_t),
l_new_stake_lock_emission);
@@ -3175,7 +2996,7 @@ int dap_ledger_emission_for_stake_lock_item_add(dap_ledger_t *a_ledger, const da
dap_ledger_stake_lock_item_t *s_emissions_for_stake_lock_item_find(dap_ledger_t *a_ledger, const dap_chain_hash_fast_t *a_token_emission_hash)
{
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_stake_lock_item_t *l_new_stake_lock_emission;
+ dap_ledger_stake_lock_item_t *l_new_stake_lock_emission = NULL;
pthread_rwlock_rdlock(&l_ledger_pvt->stake_lock_rwlock);
HASH_FIND(hh, l_ledger_pvt->emissions_for_stake_lock, a_token_emission_hash, sizeof(dap_chain_hash_fast_t),
l_new_stake_lock_emission);
@@ -3188,7 +3009,7 @@ int dap_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token_emiss
size_t a_token_emission_size, dap_hash_fast_t *a_token_emission_hash)
{
if (dap_chain_net_get_load_mode(a_ledger->net)) {
- dap_ledger_token_emission_item_t *l_token_emission_item;
+ dap_ledger_token_emission_item_t *l_token_emission_item = NULL;
dap_ledger_token_item_t *l_token_item, *l_item_tmp;
pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
HASH_ITER(hh, PVT(a_ledger)->tokens, l_token_item, l_item_tmp) {
@@ -3202,15 +3023,8 @@ int dap_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token_emiss
}
}
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
- pthread_rwlock_rdlock(&PVT(a_ledger)->threshold_emissions_rwlock);
- HASH_FIND(hh, PVT(a_ledger)->threshold_emissions, a_token_emission_hash, sizeof(*a_token_emission_hash),
- l_token_emission_item);
- pthread_rwlock_unlock(&PVT(a_ledger)->threshold_emissions_rwlock);
- if (l_token_emission_item) {
- return -5;
- }
}
- return dap_ledger_token_emission_add(a_ledger, a_token_emission, a_token_emission_size, a_token_emission_hash, false);
+ return dap_ledger_token_emission_add(a_ledger, a_token_emission, a_token_emission_size, a_token_emission_hash);
}
dap_ledger_token_emission_item_t *s_emission_item_find(dap_ledger_t *a_ledger,
@@ -3271,7 +3085,7 @@ const char* dap_ledger_tx_get_token_ticker_by_hash(dap_ledger_t *a_ledger,dap_ch
if ( dap_hash_fast_is_blank(a_tx_hash) )
return NULL;
- dap_ledger_tx_item_t *l_item;
+ dap_ledger_tx_item_t *l_item = NULL;
unsigned l_hash_value;
HASH_VALUE(a_tx_hash, sizeof(*a_tx_hash), l_hash_value);
pthread_rwlock_rdlock(&l_ledger_pvt->ledger_rwlock);
@@ -3361,7 +3175,7 @@ static dap_chain_datum_tx_t* s_find_datum_tx_by_hash(dap_ledger_t *a_ledger, con
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
dap_chain_datum_tx_t *l_tx_ret = NULL;
- dap_ledger_tx_item_t *l_tx_item;
+ dap_ledger_tx_item_t *l_tx_item = NULL;
pthread_rwlock_rdlock(&l_ledger_pvt->ledger_rwlock);
HASH_FIND(hh, l_ledger_pvt->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_item);
pthread_rwlock_unlock(&l_ledger_pvt->ledger_rwlock);
@@ -3395,7 +3209,7 @@ dap_hash_fast_t *dap_ledger_get_final_chain_tx_hash(dap_ledger_t *a_ledger, dap_
if (!a_ledger || !a_tx_hash || dap_hash_fast_is_blank(a_tx_hash))
return NULL;
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_tx_item_t *l_item;
+ dap_ledger_tx_item_t *l_item = NULL;
unsigned l_hash_value;
dap_chain_hash_fast_t *l_tx_hash = a_tx_hash;
pthread_rwlock_rdlock(&l_ledger_pvt->ledger_rwlock);
@@ -3571,14 +3385,14 @@ bool dap_ledger_tx_service_info(dap_ledger_t *a_ledger, dap_hash_fast_t *a_tx_ha
{
//find tx
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
- dap_ledger_tx_item_t *l_tx_item;
+ dap_ledger_tx_item_t *l_tx_item = NULL;
pthread_rwlock_rdlock(&l_ledger_pvt->ledger_rwlock);
HASH_FIND(hh, l_ledger_pvt->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_item);
pthread_rwlock_unlock(&l_ledger_pvt->ledger_rwlock);
if(l_tx_item) {
- dap_ledger_service_info_t *l_sinfo;
+ dap_ledger_service_info_t *l_sinfo = NULL;
pthread_rwlock_rdlock(&s_services_rwlock);
HASH_FIND_INT(s_services, &l_tx_item->cache_data.tag, l_sinfo);
pthread_rwlock_unlock(&s_services_rwlock);
@@ -3664,15 +3478,13 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
{
dap_return_val_if_fail(a_ledger && a_tx && a_tx_hash, DAP_LEDGER_CHECK_INVALID_ARGS);
if (!dap_chain_net_get_load_mode(a_ledger->net) && !a_from_threshold && !a_check_for_removing) {
- dap_ledger_tx_item_t *l_ledger_item;
+ dap_ledger_tx_item_t *l_ledger_item = NULL;
pthread_rwlock_rdlock(&PVT(a_ledger)->ledger_rwlock);
HASH_FIND(hh, PVT(a_ledger)->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_ledger_item);
pthread_rwlock_unlock(&PVT(a_ledger)->ledger_rwlock);
if (l_ledger_item) { // transaction already present in the cache list
if (s_debug_more) {
- char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_chain_hash_fast_to_str(a_tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
- log_it(L_WARNING, "Transaction %s already present in the cache", l_tx_hash_str);
+ log_it(L_WARNING, "Transaction %s already present in the cache", dap_chain_hash_fast_to_str_static(a_tx_hash));
if (a_tag) *a_tag = l_ledger_item->cache_data.tag;
if (a_action) *a_action = l_ledger_item->cache_data.action;
}
@@ -3695,7 +3507,6 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
* &&
* 7. valid(fee)
*/
-
dap_list_t *l_list_bound_items = NULL;
dap_list_t *l_list_tx_out = NULL;
@@ -4160,7 +3971,7 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
l_owner = dap_sign_compare_pkeys(l_owner_sign, l_sign);
// 5b. Call verificator for conditional output
- dap_ledger_verificator_t *l_verificator;
+ dap_ledger_verificator_t *l_verificator = NULL;
int l_sub_tmp = l_tx_prev_out_cond->header.subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
@@ -4438,30 +4249,36 @@ static int s_tx_cache_check(dap_ledger_t *a_ledger,
}
}
-
- dap_list_t *l_items_voting;
- if ((l_items_voting = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTING, NULL))) {
- if (s_voting_callbacks.voting_callback){
- if (!s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTING, a_tx, false)){
- debug_if(s_debug_more, L_WARNING, "Verificator check error for voting.");
- l_err_num = DAP_LEDGER_TX_CHECK_VERIFICATOR_CHECK_FAILURE;
- }
- } else {
- debug_if(s_debug_more, L_WARNING, "Verificator check error for voting item");
- l_err_num = DAP_LEDGER_TX_CHECK_NO_VERIFICATOR_SET;
- }
- dap_list_free(l_items_voting);
- }else if ((l_items_voting = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTE, NULL))) {
- if (s_voting_callbacks.voting_callback){
- if (!s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTE, a_tx, false)){
- debug_if(s_debug_more, L_WARNING, "Verificator check error for vote.");
- l_err_num = DAP_LEDGER_TX_CHECK_VERIFICATOR_CHECK_FAILURE;
+ if (!l_err_num) {
+ // TODO move it to service tag deduction
+ dap_list_t *l_items_voting;
+ if ((l_items_voting = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTING, NULL))) {
+ if (s_voting_callbacks.voting_callback){
+ if (!s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTING, a_tx, false)){
+ debug_if(s_debug_more, L_WARNING, "Verificator check error for voting.");
+ l_err_num = DAP_LEDGER_TX_CHECK_VERIFICATOR_CHECK_FAILURE;
+ }
+ } else {
+ debug_if(s_debug_more, L_WARNING, "Verificator check error for voting item");
+ l_err_num = DAP_LEDGER_TX_CHECK_NO_VERIFICATOR_SET;
+ }
+ dap_list_free(l_items_voting);
+ if (a_tag)
+ a_tag->uint64 = DAP_CHAIN_TX_TAG_ACTION_VOTING;
+ }else if ((l_items_voting = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTE, NULL))) {
+ if (s_voting_callbacks.voting_callback){
+ if (!s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTE, a_tx, false)){
+ debug_if(s_debug_more, L_WARNING, "Verificator check error for vote.");
+ l_err_num = DAP_LEDGER_TX_CHECK_VERIFICATOR_CHECK_FAILURE;
+ }
+ } else {
+ debug_if(s_debug_more, L_WARNING, "Verificator check error for vote item");
+ l_err_num = DAP_LEDGER_TX_CHECK_NO_VERIFICATOR_SET;
}
- } else {
- debug_if(s_debug_more, L_WARNING, "Verificator check error for vote item");
- l_err_num = DAP_LEDGER_TX_CHECK_NO_VERIFICATOR_SET;
- }
- dap_list_free(l_items_voting);
+ dap_list_free(l_items_voting);
+ if (a_tag)
+ a_tag->uint64 = DAP_CHAIN_TX_TAG_ACTION_VOTE;
+ }
}
if (a_main_ticker && !l_err_num)
@@ -4542,10 +4359,13 @@ static int s_balance_cache_update(dap_ledger_t *a_ledger, dap_ledger_wallet_bala
return 0;
}
-static int s_sort_ledger_tx_item(dap_ledger_tx_item_t* a, dap_ledger_tx_item_t* b)
+static int s_sort_ledger_tx_item(dap_ledger_tx_item_t *a, dap_ledger_tx_item_t *b)
{
- return a->tx->header.ts_created == b->tx->header.ts_created ? 0 :
- a->tx->header.ts_created < b->tx->header.ts_created ? -1 : 1;
+ if (a->cache_data.ts_created < b->cache_data.ts_created)
+ return -1;
+ if (a->cache_data.ts_created == b->cache_data.ts_created)
+ return 0;
+ return 1;
}
/**
@@ -4574,15 +4394,15 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
dap_chain_hash_fast_to_str(a_tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
int l_ret_check;
- l_item_tmp = NULL;
dap_chain_net_srv_uid_t l_tag = { .uint64 = 0 };
dap_chain_tx_tag_action_type_t l_action = DAP_CHAIN_TX_TAG_ACTION_UNKNOWN;
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))) {
- if (l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS ||
- l_ret_check == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION) {
+ 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)) {
if (!l_from_threshold) {
unsigned l_hash_value = 0;
HASH_VALUE(a_tx_hash, sizeof(*a_tx_hash), l_hash_value);
@@ -4608,6 +4428,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
return -1;
}
l_item_tmp->ts_added = dap_nanotime_now();
+ l_item_tmp->cache_data.ts_created = a_tx->header.ts_created;
HASH_ADD_BYHASHVALUE(hh, l_ledger_pvt->threshold_txs, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_hash_value, l_item_tmp);
if(s_debug_more)
log_it (L_DEBUG, "Tx %s added to threshold", l_tx_hash_str);
@@ -4720,7 +4541,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
case TX_ITEM_TYPE_IN_COND: { // all balance deducts performed with previous conditional transaction
// Update service items if any
- dap_ledger_verificator_t *l_verificator;
+ dap_ledger_verificator_t *l_verificator = NULL;
int l_tmp = l_bound_item->cond->header.subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
@@ -4755,7 +4576,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
l_cache_used_outs[l_spent_idx].timestamp = dap_nanotime_now();
}
// mark previous transactions as used with the extra timestamp
- if(l_prev_item_out->cache_data.n_outs_used == l_prev_item_out->cache_data.n_outs)
+ if (l_prev_item_out->cache_data.n_outs_used == l_prev_item_out->cache_data.n_outs)
l_prev_item_out->cache_data.ts_spent = a_tx->header.ts_created;
}
@@ -4763,16 +4584,17 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
//Update balance : raise
bool l_multichannel = false;
bool l_cross_network = false;
- for (dap_list_t *l_tx_out = l_list_tx_out; l_tx_out; l_tx_out = dap_list_next(l_tx_out)) {
+ uint32_t l_outs_count = 0;
+ for (dap_list_t *l_tx_out = l_list_tx_out; l_tx_out; l_tx_out = l_tx_out->next, l_outs_count++) {
if (!l_tx_out->data) {
- debug_if(s_debug_more, L_WARNING, "Can't detect tx ticker or matching output, can't append balances cache");
+ log_it(L_ERROR, "Can't detect tx ticker or matching output, can't append balances cache");
continue;
}
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_tx_out->data;
if (l_type == TX_ITEM_TYPE_OUT_COND) {
// Update service items if any
dap_chain_tx_out_cond_t *l_cond = (dap_chain_tx_out_cond_t *)l_tx_out->data;
- dap_ledger_verificator_t *l_verificator;
+ dap_ledger_verificator_t *l_verificator = NULL;
int l_tmp = l_cond->header.subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
@@ -4805,7 +4627,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
l_multichannel = true;
} break;
default:
- log_it(L_DEBUG, "Unknown item type %d", l_type);
+ log_it(L_ERROR, "Unknown item type %d", l_type);
break;
}
if (!l_addr)
@@ -4848,14 +4670,11 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
s_balance_cache_update(a_ledger, wallet_balance);
}
}
- dap_list_t *l_items_voting;
- if ((l_items_voting = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTING, NULL)) && s_voting_callbacks.voting_callback) {
- dap_list_free(l_items_voting);
- s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTING, a_tx, true);
- }
- else if ((l_items_voting = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTE, NULL)) && s_voting_callbacks.voting_callback) {
- dap_list_free(l_items_voting);
- s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTE, a_tx, true);
+ if (s_voting_callbacks.voting_callback) {
+ if (l_tag.uint64 == DAP_CHAIN_TX_TAG_ACTION_VOTING)
+ s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTING, a_tx, true);
+ else if (l_tag.uint64 == DAP_CHAIN_TX_TAG_ACTION_VOTE)
+ s_voting_callbacks.voting_callback(a_ledger, TX_ITEM_TYPE_VOTE, a_tx, true);
}
// add transaction to the cache list
@@ -4868,22 +4687,18 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
l_tx_item->tx_hash_fast = *a_tx_hash;
size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
l_tx_item->tx = l_ledger_pvt->mapped ? a_tx : DAP_DUP_SIZE(a_tx, l_tx_size);
- l_tx_item->cache_data.ts_created = dap_time_now(); // Time of transasction added to ledger
- int l_outs_count = 0;
- dap_list_t *l_list_tmp = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_ALL, &l_outs_count);
l_tx_item->cache_data.n_outs = l_outs_count;
l_tx_item->cache_data.tag = l_tag;
l_tx_item->cache_data.action = l_action;
- // TODO: dump the UTXO in debug mode if need
-
- if(l_list_tmp)
- dap_list_free(l_list_tmp);
dap_stpcpy(l_tx_item->cache_data.token_ticker, l_main_token_ticker);
l_tx_item->cache_data.multichannel = l_multichannel;
- pthread_rwlock_wrlock(&l_ledger_pvt->ledger_rwlock);
l_tx_item->ts_added = dap_nanotime_now();
- HASH_ADD_INORDER(hh, l_ledger_pvt->ledger_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t),
+ pthread_rwlock_wrlock(&l_ledger_pvt->ledger_rwlock);
+ if (dap_chain_net_get_load_mode(a_ledger->net))
+ HASH_ADD(hh, l_ledger_pvt->ledger_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_tx_item);
+ else
+ HASH_ADD_INORDER(hh, l_ledger_pvt->ledger_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t),
l_tx_item, s_sort_ledger_tx_item); // tx_hash_fast: name of key field
pthread_rwlock_unlock(&l_ledger_pvt->ledger_rwlock);
// Callable callback
@@ -4916,7 +4731,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
if (dap_global_db_set_raw(l_cache_used_outs, l_outs_used + 1, NULL, NULL))
debug_if(s_debug_more, L_WARNING, "Ledger cache mismatch");
}
- if (!a_from_threshold)
+ if (!a_from_threshold && l_ledger_pvt->threshold_enabled)
s_threshold_txs_proc(a_ledger);
FIN:
if (l_list_bound_items)
@@ -4936,6 +4751,13 @@ FIN:
return l_ret;
}
+void dap_leger_load_end(dap_ledger_t *a_ledger)
+{
+ pthread_rwlock_wrlock(&PVT(a_ledger)->ledger_rwlock);
+ HASH_SORT(PVT(a_ledger)->ledger_items, s_sort_ledger_tx_item);
+ pthread_rwlock_unlock(&PVT(a_ledger)->ledger_rwlock);
+}
+
/**
* @brief Remove transaction from the cache list
* @param a_ledger
@@ -4950,6 +4772,7 @@ int dap_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
dap_ledger_private_t *l_ledger_pvt = PVT(a_ledger);
dap_list_t *l_list_bound_items = NULL;
dap_list_t *l_list_tx_out = NULL;
+ dap_chain_net_srv_uid_t l_tag = { .uint64 = 0 };
char l_main_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX] = { '\0' };
char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
@@ -4960,13 +4783,13 @@ int dap_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
int l_ret_check;
if( (l_ret_check = s_tx_cache_check(a_ledger, a_tx, a_tx_hash, false,
&l_list_bound_items, &l_list_tx_out,
- l_main_token_ticker, NULL, NULL, true))) {
+ l_main_token_ticker, &l_tag, NULL, true))) {
debug_if(s_debug_more, L_WARNING, "dap_ledger_tx_remove() tx %s not passed the check: %s ", l_tx_hash_str,
dap_ledger_check_error_str(l_ret_check));
return l_ret_check;
}
- dap_ledger_tx_item_t *l_ledger_item;
+ dap_ledger_tx_item_t *l_ledger_item = NULL;
pthread_rwlock_rdlock(&PVT(a_ledger)->ledger_rwlock);
HASH_FIND(hh, PVT(a_ledger)->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_ledger_item);
pthread_rwlock_unlock(&PVT(a_ledger)->ledger_rwlock);
@@ -5055,7 +4878,7 @@ int dap_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
case TX_ITEM_TYPE_IN_COND: { // all balance deducts performed with previous conditional transaction
// Update service items if any
- dap_ledger_verificator_t *l_verificator;
+ dap_ledger_verificator_t *l_verificator = NULL;
int l_tmp = l_bound_item->cond->header.subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
@@ -5109,7 +4932,7 @@ int dap_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
if (l_type == TX_ITEM_TYPE_OUT_COND) {
// Update service items if any
dap_chain_tx_out_cond_t *l_cond = (dap_chain_tx_out_cond_t *)l_tx_out->data;
- dap_ledger_verificator_t *l_verificator;
+ dap_ledger_verificator_t *l_verificator = NULL;
int l_tmp = l_cond->header.subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
@@ -5172,11 +4995,12 @@ int dap_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
}
}
- if (dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTING, NULL) && s_voting_callbacks.voting_delete_callback)
- s_voting_callbacks.voting_delete_callback(a_ledger, TX_ITEM_TYPE_VOTING, a_tx);
- else if (dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_VOTE, NULL) && s_voting_callbacks.voting_delete_callback)
- s_voting_callbacks.voting_delete_callback(a_ledger, TX_ITEM_TYPE_VOTE, a_tx);
-
+ if (s_voting_callbacks.voting_delete_callback) {
+ if (l_tag.uint64 == DAP_CHAIN_TX_TAG_ACTION_VOTING)
+ s_voting_callbacks.voting_delete_callback(a_ledger, TX_ITEM_TYPE_VOTING, a_tx);
+ else if (l_tag.uint64 == DAP_CHAIN_TX_TAG_ACTION_VOTE)
+ s_voting_callbacks.voting_delete_callback(a_ledger, TX_ITEM_TYPE_VOTE, a_tx);
+ }
// remove transaction from ledger
dap_ledger_tx_item_t *l_tx_item = NULL;
@@ -5231,19 +5055,14 @@ int dap_ledger_tx_load(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_c
if (dap_chain_net_get_load_mode(a_ledger->net)) {
if (PVT(a_ledger)->cache_tx_check_callback)
PVT(a_ledger)->cache_tx_check_callback(a_ledger, a_tx_hash);
- dap_ledger_tx_item_t *l_tx_item;
+ dap_ledger_tx_item_t *l_tx_item = NULL;
unsigned l_hash_value;
HASH_VALUE(a_tx_hash, sizeof(dap_chain_hash_fast_t), l_hash_value);
pthread_rwlock_rdlock(&PVT(a_ledger)->ledger_rwlock);
HASH_FIND_BYHASHVALUE(hh, PVT(a_ledger)->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_hash_value, l_tx_item);
- if (l_tx_item) {
- pthread_rwlock_unlock(&PVT(a_ledger)->ledger_rwlock);
- return DAP_LEDGER_CHECK_ALREADY_CACHED;
- }
- HASH_FIND_BYHASHVALUE(hh, PVT(a_ledger)->threshold_txs, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_hash_value, l_tx_item);
pthread_rwlock_unlock(&PVT(a_ledger)->ledger_rwlock);
if (l_tx_item)
- return DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS;
+ return DAP_LEDGER_CHECK_ALREADY_CACHED;
}
#endif
return dap_ledger_tx_add(a_ledger, a_tx, a_tx_hash, false);
@@ -5259,7 +5078,6 @@ void dap_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
pthread_rwlock_wrlock(&l_ledger_pvt->ledger_rwlock);
pthread_rwlock_wrlock(&l_ledger_pvt->tokens_rwlock);
- pthread_rwlock_wrlock(&l_ledger_pvt->threshold_emissions_rwlock);
pthread_rwlock_wrlock(&l_ledger_pvt->threshold_txs_rwlock);
pthread_rwlock_wrlock(&l_ledger_pvt->balance_accounts_rwlock);
pthread_rwlock_wrlock(&l_ledger_pvt->stake_lock_rwlock);
@@ -5341,12 +5159,6 @@ void dap_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
DAP_DELETE(l_gdb_group);
}
- /* Delete threshold emissions */
- HASH_ITER(hh, l_ledger_pvt->threshold_emissions, l_emission_current, l_emission_tmp) {
- HASH_DEL(l_ledger_pvt->threshold_emissions, l_emission_current);
- DAP_DELETE(l_emission_current->datum_token_emission);
- DAP_DEL_Z(l_emission_current);
- }
/* Delete threshold transactions */
HASH_ITER(hh, l_ledger_pvt->threshold_txs, l_item_current, l_item_tmp) {
HASH_DEL(l_ledger_pvt->threshold_txs, l_item_current);
@@ -5358,12 +5170,10 @@ void dap_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
l_ledger_pvt->ledger_items = NULL;
l_ledger_pvt->balance_accounts = NULL;
l_ledger_pvt->tokens = NULL;
- l_ledger_pvt->threshold_emissions = NULL;
l_ledger_pvt->threshold_txs = NULL;
pthread_rwlock_unlock(&l_ledger_pvt->ledger_rwlock);
pthread_rwlock_unlock(&l_ledger_pvt->tokens_rwlock);
- pthread_rwlock_unlock(&l_ledger_pvt->threshold_emissions_rwlock);
pthread_rwlock_unlock(&l_ledger_pvt->threshold_txs_rwlock);
pthread_rwlock_unlock(&l_ledger_pvt->balance_accounts_rwlock);
pthread_rwlock_unlock(&l_ledger_pvt->stake_lock_rwlock);
@@ -6003,7 +5813,7 @@ dap_list_t *dap_ledger_get_list_tx_outs(dap_ledger_t *a_ledger, const char *a_to
// Add new verificator callback with associated subtype. Returns 1 if callback replaced, -1 error, overwise returns 0
int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_ledger_verificator_callback_t a_callback, dap_ledger_updater_callback_t a_callback_added, dap_ledger_updater_callback_t a_callback_deleted)
{
- dap_ledger_verificator_t *l_new_verificator;
+ dap_ledger_verificator_t *l_new_verificator = NULL;
int l_tmp = (int)a_subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_new_verificator);
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index f6e2b577971868399474b47462176370aa6d8515..c6db7513308769ae5723621aa32e0300c3bdbeea 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -1795,7 +1795,7 @@ void dap_chain_net_delete(dap_chain_net_t *a_net)
// Synchronously going to offline state
PVT(a_net)->state = PVT(a_net)->state_target = NET_STATE_OFFLINE;
s_net_states_proc(a_net);
- dap_chain_net_item_t *l_net_item;
+ 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);
@@ -2133,6 +2133,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
for (dap_chain_t *l_chain = l_net->pub.chains; l_chain; l_chain = l_chain->next) {
if (l_chain->callback_load_from_gdb) {
l_ledger_flags &= ~DAP_LEDGER_MAPPED;
+ l_ledger_flags |= DAP_LEDGER_THRESHOLD_ENABLED;
continue;
}
if (!l_chain->callback_get_poa_certs)
@@ -2199,6 +2200,10 @@ bool s_net_load(void *a_arg)
} else
log_it(L_WARNING, "No purge callback for chain %s, can't reload it with correct order", l_chain->name);
}
+ if (l_chain->callback_atom_add_from_treshold) {
+ while (l_chain->callback_atom_add_from_treshold(l_chain, NULL))
+ log_it(L_DEBUG, "Added atom from treshold");
+ }
} else {
//dap_chain_save_all( l_chain );
log_it (L_NOTICE, "Initialized chain files");
@@ -2206,23 +2211,11 @@ bool s_net_load(void *a_arg)
l_chain->atom_num_last = 0;
l_chain = l_chain->next;
}
- // Process thresholds if any
- bool l_processed;
- do {
- l_processed = false;
- DL_FOREACH(l_net->pub.chains, l_chain) {
- if (l_chain->callback_atom_add_from_treshold) {
- while (l_chain->callback_atom_add_from_treshold(l_chain, NULL)) {
- log_it(L_DEBUG, "Added atom from treshold");
- l_processed = true;
- }
- }
- }
- } while (l_processed);
+ l_net_pvt->load_mode = false;
+ dap_leger_load_end(l_net->pub.ledger);
// Do specific role actions post-chain created
l_net_pvt->state_target = NET_STATE_OFFLINE;
-
switch ( l_net_pvt->node_role.enums ) {
case NODE_ROLE_ROOT_MASTER:{
// Set to process everything in datum pool
@@ -2263,8 +2256,6 @@ bool s_net_load(void *a_arg)
log_it(L_INFO,"Light node role established");
}
-
- l_net_pvt->load_mode = false;
l_net_pvt->balancer_type = dap_config_get_item_bool_default(l_net->pub.config, "general", "use_dns_links", false);
diff --git a/modules/net/dap_chain_net_decree.c b/modules/net/dap_chain_net_decree.c
index f8ae4a95ce09ddb10667a3e41439f75529b175c4..7dc38736dfc1b3211bffbe33e973a705d41acd7c 100644
--- a/modules/net/dap_chain_net_decree.c
+++ b/modules/net/dap_chain_net_decree.c
@@ -131,7 +131,7 @@ static int s_decree_verify(dap_chain_net_t *a_net, dap_chain_datum_decree_t *a_d
return -122;
}
- decree_table_t **l_decrees = dap_chain_net_get_decrees(a_net), *l_sought_decree;
+ decree_table_t **l_decrees = dap_chain_net_get_decrees(a_net), *l_sought_decree = NULL;
HASH_FIND(hh, *l_decrees, a_decree_hash, sizeof(dap_hash_fast_t), l_sought_decree);
if (l_sought_decree && l_sought_decree->decree) {
log_it(L_WARNING, "Decree with hash %s is already present", dap_hash_fast_to_str_static(a_decree_hash));
@@ -243,7 +243,7 @@ int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_d
return -108;
}
- decree_table_t **l_decrees = dap_chain_net_get_decrees(l_net), *l_new_decree;
+ decree_table_t **l_decrees = dap_chain_net_get_decrees(l_net), *l_new_decree = NULL;
HASH_FIND(hh, *l_decrees, a_decree_hash, sizeof(dap_hash_fast_t), l_new_decree);
if (!l_new_decree) {
l_new_decree = DAP_NEW_Z(decree_table_t);
@@ -327,7 +327,7 @@ int dap_chain_net_decree_reset_applied(dap_chain_net_t *a_net, dap_chain_hash_fa
{
if (!a_net || !a_decree_hash)
return -1;
- decree_table_t **l_decrees = dap_chain_net_get_decrees(a_net), *l_sought_decree;
+ decree_table_t **l_decrees = dap_chain_net_get_decrees(a_net), *l_sought_decree = NULL;
HASH_FIND(hh, *l_decrees, a_decree_hash, sizeof(dap_hash_fast_t), l_sought_decree);
if (!l_sought_decree)
return -2;
@@ -337,7 +337,7 @@ int dap_chain_net_decree_reset_applied(dap_chain_net_t *a_net, dap_chain_hash_fa
dap_chain_datum_decree_t *dap_chain_net_decree_get_by_hash(dap_chain_net_t *a_net, dap_hash_fast_t *a_hash, bool *is_applied)
{
- decree_table_t **l_decrees = dap_chain_net_get_decrees(a_net), *l_sought_decree;
+ decree_table_t **l_decrees = dap_chain_net_get_decrees(a_net), *l_sought_decree = NULL;
HASH_FIND(hh, *l_decrees, a_hash, sizeof(dap_hash_fast_t), l_sought_decree);
return ( !l_sought_decree || !l_sought_decree->decree )
? NULL
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index 1603d8fdbf88ab95364dda0360d4d3bc1f2efcf2..eebf0a96a1ea50552eca418759964b4bb59a530e 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -268,12 +268,6 @@ bool dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_d
return false;
}
int l_verify_datum = dap_chain_net_verify_datum_for_add(a_chain, a_datum, &l_datum_hash);
- if (l_verify_datum != 0 &&
- l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS &&
- l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION &&
- l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_NOT_ENOUGH_SIGNS &&
- l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_NO_DECREE)
- return true;
if (!l_verify_datum
#ifdef DAP_TPS_TEST
|| l_verify_datum == DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS
@@ -282,6 +276,12 @@ bool dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_d
{
a_chain->callback_add_datums(a_chain, &a_datum, 1);
}
+ if (l_verify_datum != 0 &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_NOT_ENOUGH_SIGNS &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_NO_DECREE)
+ return true;
return false;
}
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index e988cb3ed57fde2c6f93eb627054f0b545631a08..adca25fca8d1cba72836e9f6070df7dd744feedd 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -943,7 +943,7 @@ int com_ledger(int a_argc, char ** a_argv, void **reply)
if(l_cmd == CMD_LIST){
enum {SUBCMD_NONE, SUBCMD_LIST_COIN, SUB_CMD_LIST_LEDGER_THRESHOLD, SUB_CMD_LIST_LEDGER_BALANCE, SUB_CMD_LIST_LEDGER_THRESHOLD_WITH_HASH};
int l_sub_cmd = SUBCMD_NONE;
- dap_chain_hash_fast_t l_tx_threshold_hash;
+ dap_chain_hash_fast_t l_tx_threshold_hash = {};
const char *l_limit_str = NULL;
const char *l_offset_str = NULL;
if (dap_cli_server_cmd_find_option_val(a_argv, 2, 3, "coins", NULL ))
@@ -981,21 +981,21 @@ int com_ledger(int a_argc, char ** a_argv, void **reply)
dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_LEDGER_LACK_ERR, "Can't get ledger for net %s", l_net_str);
return DAP_CHAIN_NODE_CLI_COM_LEDGER_LACK_ERR;
}
- if (l_sub_cmd == SUB_CMD_LIST_LEDGER_THRESHOLD){
- json_object* json_obj_out = dap_ledger_threshold_info(l_ledger, l_limit, l_offset);
+ if (l_sub_cmd == SUB_CMD_LIST_LEDGER_THRESHOLD) {
+ json_object* json_obj_out = dap_ledger_threshold_info(l_ledger, l_limit, l_offset, NULL);
if (json_obj_out){
json_object_array_add(*json_arr_reply, json_obj_out);
}
return 0;
}
- if (l_sub_cmd == SUB_CMD_LIST_LEDGER_THRESHOLD_WITH_HASH){
- json_object *json_obj_out = dap_ledger_threshold_hash_info(l_ledger, &l_tx_threshold_hash, l_limit, l_offset);
+ if (l_sub_cmd == SUB_CMD_LIST_LEDGER_THRESHOLD_WITH_HASH) {
+ json_object *json_obj_out = dap_ledger_threshold_info(l_ledger, 0, 0, &l_tx_threshold_hash);
if (json_obj_out){
json_object_array_add(*json_arr_reply, json_obj_out);
}
return 0;
}
- if (l_sub_cmd == SUB_CMD_LIST_LEDGER_BALANCE){
+ if (l_sub_cmd == SUB_CMD_LIST_LEDGER_BALANCE) {
json_object *json_obj_out = dap_ledger_balance_info(l_ledger, l_limit, l_offset);
if (json_obj_out){
json_object_array_add(*json_arr_reply, json_obj_out);
diff --git a/modules/net/dap_chain_node_dns_server.c b/modules/net/dap_chain_node_dns_server.c
index 3a14319538f31be19b0d7eea411959d994184b9e..9b70440eb0b527b3d5c99dffebd0eca68be63158 100644
--- a/modules/net/dap_chain_node_dns_server.c
+++ b/modules/net/dap_chain_node_dns_server.c
@@ -49,7 +49,7 @@ static char s_root_alias[] = "dnsroot";
* @return 0 if success, else return error code
*/
int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback) {
- dap_dns_zone_hash_t *new_zone;
+ dap_dns_zone_hash_t *new_zone = NULL;
HASH_FIND_STR(s_dns_server->hash_table, zone, new_zone);
if (new_zone == NULL) { // zone is not present
DAP_NEW_Z_RET_VAL(new_zone, dap_dns_zone_hash_t, DNS_ERROR_FAILURE, NULL);
@@ -66,7 +66,7 @@ int dap_dns_zone_register(char *zone, dap_dns_zone_callback_t callback) {
* @return 0 if success, else return error code
*/
int dap_dns_zone_unregister(char *zone) {
- dap_dns_zone_hash_t *asked_zone;
+ dap_dns_zone_hash_t *asked_zone = NULL;
HASH_FIND_STR(s_dns_server->hash_table, zone, asked_zone);
if (asked_zone == NULL) {
return DNS_ERROR_NAME;
@@ -83,7 +83,7 @@ int dap_dns_zone_unregister(char *zone) {
* @return Callback for registered DNS zone, else return NULL
*/
dap_dns_zone_callback_t dap_dns_zone_find(char *hostname) {
- dap_dns_zone_hash_t *asked_zone;
+ dap_dns_zone_hash_t *asked_zone = NULL;
HASH_FIND_STR(s_dns_server->hash_table, hostname, asked_zone);
if (asked_zone == NULL) {
if (!strcmp(hostname, &s_root_alias[0])) {
diff --git a/modules/net/include/dap_chain_ledger.h b/modules/net/include/dap_chain_ledger.h
index b54200afe368c4e63b633eef83c91e2ec8821ac4..c81920485e18d0e532892cdea39838a4c28adf9e 100644
--- a/modules/net/include/dap_chain_ledger.h
+++ b/modules/net/include/dap_chain_ledger.h
@@ -89,11 +89,11 @@ typedef enum dap_ledger_check_error {
DAP_LEDGER_TX_CHECK_NOT_ENOUGH_FEE,
DAP_LEDGER_TX_CHECK_NOT_ENOUGH_TAX,
/* Emisssion check return codes */
- DAP_LEDGER_EMISSION_CHECK_THRESHOLDED,
- DAP_LEDGER_EMISSION_CHECK_THRESHOLD_OVERFLOW,
DAP_LEDGER_EMISSION_CHECK_VALUE_EXCEEDS_CURRENT_SUPPLY,
+ DAP_LEDGER_EMISSION_CHECK_LEGACY_FORBIDDEN,
/* Token declaration/update return codes */
DAP_LEDGER_TOKEN_ADD_CHECK_NOT_ENOUGH_UNIQUE_SIGNS,
+ DAP_LEDGER_TOKEN_ADD_CHECK_LEGACY_FORBIDDEN,
DAP_LEDGER_TOKEN_ADD_CHECK_TSD_INVALID_SUPPLY,
DAP_LEDGER_TOKEN_ADD_CHECK_TSD_INVALID_ADDR,
DAP_LEDGER_TOKEN_ADD_CHECK_TSD_ADDR_MISMATCH,
@@ -145,11 +145,11 @@ DAP_STATIC_INLINE const char *dap_ledger_check_error_str(dap_ledger_check_error_
case DAP_LEDGER_TX_CHECK_NOT_ENOUGH_FEE: return "Not enough network fee for transaction processing";
case DAP_LEDGER_TX_CHECK_NOT_ENOUGH_TAX: return "Not enough sovereign tax provided with current transaction";
/* Emisssion check return codes */
- case DAP_LEDGER_EMISSION_CHECK_THRESHOLDED: return "No token ticker found for emission, move it to the threshold";
- case DAP_LEDGER_EMISSION_CHECK_THRESHOLD_OVERFLOW: return "Emissions threshold overfulled";
case DAP_LEDGER_EMISSION_CHECK_VALUE_EXCEEDS_CURRENT_SUPPLY: return "Value of emission execeeds current token supply";
+ case DAP_LEDGER_EMISSION_CHECK_LEGACY_FORBIDDEN: return "Legacy type of emissions are present for old chains comliance only";
/* Token declaration/update return codes */
case DAP_LEDGER_TOKEN_ADD_CHECK_NOT_ENOUGH_UNIQUE_SIGNS: return "Not all token signs is unique";
+ case DAP_LEDGER_TOKEN_ADD_CHECK_LEGACY_FORBIDDEN: return "Legacy type of tokens are present for old chains comliance only";
case DAP_LEDGER_TOKEN_ADD_CHECK_TSD_INVALID_SUPPLY: return "Specified supply must be greater than current one";
case DAP_LEDGER_TOKEN_ADD_CHECK_TSD_INVALID_ADDR: return "Specified address has invalid format";
case DAP_LEDGER_TOKEN_ADD_CHECK_TSD_ADDR_MISMATCH: return "Specified address can't be processed cause double (for adding) or absent (for removing)";
@@ -179,6 +179,9 @@ typedef enum dap_chain_tx_tag_action_type {
DAP_CHAIN_TX_TAG_ACTION_EXTEND = 1 << 8,
DAP_CHAIN_TX_TAG_ACTION_CHANGE = 1 << 9,
DAP_CHAIN_TX_TAG_ACTION_CLOSE = 1 << 10,
+
+ DAP_CHAIN_TX_TAG_ACTION_VOTING = 1 << 11,
+ DAP_CHAIN_TX_TAG_ACTION_VOTE = 1 << 12,
DAP_CHAIN_TX_TAG_ACTION_ALL = ~0,
@@ -221,6 +224,8 @@ typedef bool (*dap_ledger_tag_check_callback_t)(dap_ledger_t *a_ledger, dap_chai
#define DAP_LEDGER_MAPPED 0x0400
+#define DAP_LEDGER_THRESHOLD_ENABLED 0x0800
+
// Error code for no previous transaction (for stay in mempool)
#define DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS DAP_LEDGER_TX_CHECK_PREV_TX_NOT_FOUND
// Error code for no emission for a transaction (for stay in mempool)
@@ -296,8 +301,7 @@ json_object *dap_ledger_token_info_by_name(dap_ledger_t *a_ledger, const char *a
// Get all token-declarations
dap_list_t* dap_ledger_token_decl_all(dap_ledger_t *a_ledger);
-json_object *dap_ledger_threshold_info(dap_ledger_t *a_ledger, size_t a_limit, size_t a_offset);
-json_object *dap_ledger_threshold_hash_info(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *l_tx_treshold_hash, size_t a_limit, size_t a_offset);
+json_object *dap_ledger_threshold_info(dap_ledger_t *a_ledger, size_t a_limit, size_t a_offset, dap_hash_fast_t *a_threshold_hash);
json_object *dap_ledger_balance_info(dap_ledger_t *a_ledger, size_t a_limit, size_t a_offset);
size_t dap_ledger_token_get_auth_signs_valid(dap_ledger_t *a_ledger, const char *a_token_ticker);
@@ -308,8 +312,7 @@ uint256_t dap_ledger_token_get_emission_rate(dap_ledger_t *a_ledger, const char
/**
* Add token emission datum
*/
-int dap_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size,
- dap_hash_fast_t *a_emission_hash, bool a_from_threshold);
+int dap_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size, dap_hash_fast_t *a_emission_hash);
int dap_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size, dap_hash_fast_t *a_token_emission_hash);
// Checking a new transaction before adding to the cache
@@ -443,3 +446,4 @@ void dap_ledger_bridged_tx_notify_add(dap_ledger_t *a_ledger, dap_ledger_bridged
bool dap_ledger_cache_enabled(dap_ledger_t *a_ledger);
void dap_ledger_set_cache_tx_check_callback(dap_ledger_t *a_ledger, dap_ledger_cache_tx_check_callback_t a_callback);
dap_chain_tx_out_cond_t* dap_chain_ledger_get_tx_out_cond_linked_to_tx_in_cond(dap_ledger_t *a_ledger, dap_chain_tx_in_cond_t *a_in_cond);
+void dap_leger_load_end(dap_ledger_t *a_ledger);
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 8e55f3f3175e698d97497aff3eb96844f3179412..af936ef8a2993c9238854fc1b64779ac7a82c321 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -1019,7 +1019,7 @@ void dap_chain_net_srv_del(dap_chain_net_srv_t *a_srv)
// sanity check
dap_return_if_pass(!a_srv);
// func work
- service_list_t *l_sdata;
+ service_list_t *l_sdata = NULL;
// delete srv from hash table
pthread_mutex_lock(&s_srv_list_mutex);
HASH_FIND(hh, s_srv_list, a_srv, sizeof(dap_chain_net_srv_uid_t), l_sdata);
diff --git a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
index cd25bbb34f3c2ebec37003596d1339507e55d950..f432b73eeeedf22b4aa52e8c040d42a9f967e864 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
@@ -274,7 +274,7 @@ static int s_stake_verificator_callback(dap_ledger_t *a_ledger, dap_chain_tx_out
}
if (a_tx_in->header.ts_created < 1706227200) // Jan 26 2024 00:00:00 GMT, old policy rules
return 0;
- dap_chain_net_srv_stake_item_t *l_stake;
+ dap_chain_net_srv_stake_item_t *l_stake = NULL;
HASH_FIND(ht, l_srv_stake->tx_itemlist, l_prev_hash, sizeof(dap_hash_t), l_stake);
if (l_stake) {
log_it(L_WARNING, "Key is active with delegation decree, need to revoke it first");
@@ -576,7 +576,7 @@ static bool s_stake_cache_check_tx(dap_ledger_t *a_ledger, dap_hash_fast_t *a_tx
{
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(a_ledger->net->pub.id);
dap_return_val_if_fail(l_srv_stake, false);
- dap_chain_net_srv_stake_cache_item_t *l_stake;
+ dap_chain_net_srv_stake_cache_item_t *l_stake = NULL;
HASH_FIND(hh, l_srv_stake->cache, a_tx_hash, sizeof(*a_tx_hash), l_stake);
if (l_stake) {
dap_chain_net_srv_stake_key_invalidate(&l_stake->signing_addr);
@@ -2043,7 +2043,7 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified net have no stake service activated");
return -25;
}
- dap_chain_net_srv_stake_item_t *l_stake;
+ dap_chain_net_srv_stake_item_t *l_stake = NULL;
HASH_FIND(hh, l_srv_stake->itemlist, &l_signing_addr.data.hash_fast, sizeof(dap_hash_fast_t), l_stake);
if (!l_stake) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate/pkey hash is not delegated nor this delegating is approved."
@@ -2080,7 +2080,7 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified net have no stake service activated");
return -25;
}
- dap_chain_net_srv_stake_item_t *l_stake;
+ dap_chain_net_srv_stake_item_t *l_stake = NULL;
HASH_FIND(ht, l_srv_stake->tx_itemlist, &l_tx_hash, sizeof(dap_hash_t), l_stake);
if (l_stake) {
char l_pkey_hash_str[DAP_HASH_FAST_STR_SIZE];
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index d2fc9358168ca2f001a9ab7945d04cf8283a9769..b35ce03bed5cbd0b148a0967e3bb47919ec27326 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -2354,7 +2354,7 @@ static uint256_t s_callback_calc_reward(dap_chain_t *a_chain, dap_hash_fast_t *a
{
uint256_t l_ret = uint256_0;
dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
- dap_chain_block_cache_t *l_block_cache;
+ dap_chain_block_cache_t *l_block_cache = NULL;
HASH_FIND(hh, PVT(l_blocks)->blocks, a_block_hash, sizeof(*a_block_hash), l_block_cache);
if (!l_block_cache)
return l_ret;
@@ -2379,6 +2379,7 @@ static uint256_t s_callback_calc_reward(dap_chain_t *a_chain, dap_hash_fast_t *a
return l_ret;
}
dap_hash_fast_t l_prev_block_hash = l_block_cache->prev_hash;
+ l_block_cache = NULL;
HASH_FIND(hh, PVT(l_blocks)->blocks, &l_prev_block_hash, sizeof(l_prev_block_hash), l_block_cache);
if (!l_block_cache) {
log_it(L_ERROR, "l_block_cache is NULL");
@@ -2390,8 +2391,12 @@ static uint256_t s_callback_calc_reward(dap_chain_t *a_chain, dap_hash_fast_t *a
return l_ret;
}
assert(l_block);
- dap_time_t l_time_diff = l_block_time - dap_max(l_block->hdr.ts_created, DAP_REWARD_INIT_TIMESTAMP);
- MULT_256_256(l_ret, GET_256_FROM_64(l_time_diff), &l_ret);
+ dap_time_t l_cur_time = dap_max(l_block->hdr.ts_created, DAP_REWARD_INIT_TIMESTAMP);
+ dap_time_t l_time_diff = l_block_time > l_cur_time ? l_block_time - l_cur_time : 1;
+ if (MULT_256_256(l_ret, GET_256_FROM_64(l_time_diff), &l_ret)) {
+ log_it(L_ERROR, "Integer overflow while multiplication execution to calculate final reward");
+ return uint256_0;
+ }
DIV_256(l_ret, GET_256_FROM_64(s_block_timediff_unit_size * l_signs_count), &l_ret);
return l_ret;
}
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 81c8c3552e8efd8522c46b5e5330a3c2a13c2df4..707c3a9a1ace4dfd51be4cd2e29f13236090dd87 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -529,10 +529,6 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
case 0:
debug_if(s_debug_more, L_DEBUG, "... added");
break;
- case DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS:
- case DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION:
- debug_if(s_debug_more, L_DEBUG, "... ledger tresholded");
- break;
case DAP_CHAIN_DATUM_CA:
debug_if(s_debug_more, L_DEBUG, "... DATUM_CA");
break;
diff --git a/modules/wallet/dap_chain_wallet.c b/modules/wallet/dap_chain_wallet.c
index 12f8fd9ac1268e227efb7d277fc6a99a5da5dfde..0336838aebea91d9d1912834e2889f9358827bee 100644
--- a/modules/wallet/dap_chain_wallet.c
+++ b/modules/wallet/dap_chain_wallet.c
@@ -107,7 +107,7 @@ int dap_chain_wallet_activate (
)
{
int l_rc, l_rc2;
-dap_chain_wallet_n_pass_t l_rec = {0}, *l_prec;
+dap_chain_wallet_n_pass_t l_rec = {0}, *l_prec = NULL;
dap_chain_wallet_t *l_wallet;
char *c_wallets_path;
@@ -204,7 +204,7 @@ int s_dap_chain_wallet_pass (
)
{
int l_rc;
-dap_chain_wallet_n_pass_t *l_prec;
+dap_chain_wallet_n_pass_t *l_prec = NULL;
struct timespec l_now;
/* Sanity checks ... */
@@ -263,7 +263,7 @@ struct timespec l_now;
int dap_chain_wallet_deactivate (const char *a_name, ssize_t a_name_len)
{
int l_rc, l_rc2;
-dap_chain_wallet_n_pass_t *l_prec;
+dap_chain_wallet_n_pass_t *l_prec = NULL;
if ( a_name_len > DAP_WALLET$SZ_NAME )
return log_it(L_ERROR, "Wallet's name is too long (%d > %d)", (int) a_name_len, DAP_WALLET$SZ_NAME), -EINVAL;