diff --git a/dap-sdk/core/include/dap_math_ops.h b/dap-sdk/core/include/dap_math_ops.h
index 339ec574e76cb902cf55c7f9a26ad5553f445ed5..6fb636202c63fa1658012e10cf324a3b2867a2b7 100755
--- a/dap-sdk/core/include/dap_math_ops.h
+++ b/dap-sdk/core/include/dap_math_ops.h
@@ -68,7 +68,7 @@ typedef struct uint512_t {
////////////////////////////////////////////////////////////////////////////////////////////////
-#ifndef DAP_GLOBAL_IS_INT128
+#if 0
const uint128_t two_power_64={ .hi = 1, .lo = 0};
const uint128_t lo_64={ .hi = 0, .lo = 0xffffffffffffffff};
@@ -141,7 +141,7 @@ static inline uint256_t AND_256(uint256_t a_256_bit,uint256_t b_256_bit){
return output;
#else
- uint256_t output={ .hi = zero_128, .lo = zero_128};
+ uint256_t output={ .hi = {}, .lo = {}};
output.hi= AND_128(a_256_bit.hi, b_256_bit.hi);
output.lo= AND_128(a_256_bit.lo, b_256_bit.lo);
return output;
@@ -158,7 +158,7 @@ static inline uint256_t OR_256(uint256_t a_256_bit,uint256_t b_256_bit){
return output;
#else
- uint256_t output={ .hi = zero_128, .lo = zero_128};
+ uint256_t output={ .hi = {}, .lo = {}};
output.hi= OR_128(a_256_bit.hi, b_256_bit.hi);
output.lo= OR_128(a_256_bit.lo, b_256_bit.lo);
return output;
@@ -250,6 +250,7 @@ static inline void LEFT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int n
#else
if (n >= 128) // shifting 64-bit integer by more than 63 bits is not defined
{
+ uint128_t zero_128 = {};
a_256_bit.hi=a_256_bit.lo;
a_256_bit.lo=zero_128;
LEFT_SHIFT_256(a_256_bit,b_256_bit,n-128);
@@ -260,11 +261,11 @@ static inline void LEFT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int n
b_256_bit->lo=a_256_bit.lo;
}
if (n<128)
- { uint128_t shift_temp{.hi=0, .lo=0};
+ { uint128_t shift_temp={.hi=0, .lo=0};
LEFT_SHIFT_128(a_256_bit.lo,&shift_temp,n);
b_256_bit->lo=shift_temp;
- uint128_t shift_temp_or_left{.hi=0, .lo=0};
- uint128_t shift_temp_or_right{.hi=0, .lo=0};
+ uint128_t shift_temp_or_left={.hi=0, .lo=0};
+ uint128_t shift_temp_or_right={.hi=0, .lo=0};
LEFT_SHIFT_128(a_256_bit.hi,&shift_temp_or_left,n);
RIGHT_SHIFT_128(a_256_bit.lo,&shift_temp_or_right,128-n);
b_256_bit->hi=OR_128(shift_temp_or_left,shift_temp_or_right);
@@ -297,7 +298,8 @@ static inline void RIGHT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int
#else
if (n >= 128) // shifting 64-bit integer by more than 63 bits is not defined
- {
+ {
+ uint128_t zero_128 = {};
a_256_bit.lo=a_256_bit.hi;
a_256_bit.hi=zero_128;
RIGHT_SHIFT_256(a_256_bit,b_256_bit,n-128);
@@ -308,11 +310,11 @@ static inline void RIGHT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int
b_256_bit->lo=a_256_bit.lo;
}
if (n<128)
- { uint128_t shift_temp{.hi=0, .lo=0};
+ { uint128_t shift_temp={.hi=0, .lo=0};
RIGHT_SHIFT_128(a_256_bit.hi,&shift_temp,n);
b_256_bit->hi=shift_temp;
- uint128_t shift_temp_or_left{.hi=0, .lo=0};
- uint128_t shift_temp_or_right{.hi=0, .lo=0};
+ uint128_t shift_temp_or_left={.hi=0, .lo=0};
+ uint128_t shift_temp_or_right={.hi=0, .lo=0};
RIGHT_SHIFT_128(a_256_bit.lo,&shift_temp_or_left,n);
LEFT_SHIFT_128(a_256_bit.hi,&shift_temp_or_right,128-n);
b_256_bit->lo=OR_128(shift_temp_or_left,shift_temp_or_right);
@@ -359,6 +361,7 @@ static inline void INCR_256(uint256_t* a_256_bit){
#else
INCR_128(&a_256_bit->lo);
+ uint128_t zero_128 = {};
if(EQUAL_128(a_256_bit->lo, zero_128))
{
INCR_128(&a_256_bit->hi);
@@ -396,7 +399,7 @@ return overflow_flag;}
//c_128_bit->lo=a_64_bit+b_64_bit;
//c_128_bit->hi=(c_128_bit->lo<a_64_bit);}
-#ifndef DAP_GLOBAL_IS_INT128
+#if 0
//Mixed precision: add a uint64_t into a uint128_t
static inline int ADD_64_INTO_128(uint64_t a_64_bit,uint128_t* c_128_bit ) {
int overflow_flag=0;
diff --git a/dap-sdk/core/libdap.pri b/dap-sdk/core/libdap.pri
index 91e97ea660c918ec1b530a3597fd3ebbf634e823..e3b46af7e822cd9c1efc41ccb6776ff96fd5176b 100755
--- a/dap-sdk/core/libdap.pri
+++ b/dap-sdk/core/libdap.pri
@@ -73,7 +73,6 @@ HEADERS += $$PWD/include/dap_common.h \
SOURCES += $$PWD/src/dap_common.c \
$$PWD/src/dap_binary_tree.c \
$$PWD/src/dap_config.c \
- $$PWD/src/dap_math_ops.c \
$$PWD/src/dap_file_utils.c \
$$PWD/src/dap_circular_buffer.c \
$$PWD/src/dap_list.c \
diff --git a/dap-sdk/net/server/json_rpc/include/dap_json_rpc_request_handler.h b/dap-sdk/net/server/json_rpc/include/dap_json_rpc_request_handler.h
index e0f5c75b64b8096630bd9ff1fd86429da28e3b3c..65faa2b326fe983421a552fd73817fd12312de52 100644
--- a/dap-sdk/net/server/json_rpc/include/dap_json_rpc_request_handler.h
+++ b/dap-sdk/net/server/json_rpc/include/dap_json_rpc_request_handler.h
@@ -38,7 +38,7 @@
extern "C"{
#endif
-typedef void (handler_func_t)(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+typedef void (handler_func_t)(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
typedef struct dap_json_rpc_request_handler
{
diff --git a/dap-sdk/net/server/json_rpc/src/dap_json_rpc_request_handler.c b/dap-sdk/net/server/json_rpc/src/dap_json_rpc_request_handler.c
index 593c9c2104cf11600a7c501dcbdbfd2433d22c4e..d84c81576bfb9086f1e278e15c288204cdaea168 100644
--- a/dap-sdk/net/server/json_rpc/src/dap_json_rpc_request_handler.c
+++ b/dap-sdk/net/server/json_rpc/src/dap_json_rpc_request_handler.c
@@ -50,7 +50,7 @@ void dap_json_rpc_request_handler(dap_json_rpc_request_t *a_request, dap_http_s
log_it(L_NOTICE, "Can't processing the request. Handler %s not registration. ", a_request->method);
} else {
l_response->error = NULL;
- l_handler->func(a_request->params, l_response);
+ l_handler->func(a_request->params, l_response, a_request->method);
log_it(L_NOTICE, "Calling handler request name: %s", a_request->method);
}
dap_json_rpc_response_send(l_response, a_client);
diff --git a/modules/chain/btc_rpc/include/dap_chain_btc_rpc_handlers.h b/modules/chain/btc_rpc/include/dap_chain_btc_rpc_handlers.h
index 601c9dd1ff4aed16aec43cd25e18f7e1bc051752..d019041e44c27b02433a00892f8143d33cb1cec5 100644
--- a/modules/chain/btc_rpc/include/dap_chain_btc_rpc_handlers.h
+++ b/modules/chain/btc_rpc/include/dap_chain_btc_rpc_handlers.h
@@ -5,80 +5,80 @@
void dap_chain_btc_rpc_registration_handlers();
void dap_chain_btc_rpc_unregistration_handlers();
-void dap_chain_btc_rpc_handler_addmultisigaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_addnode(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_backupwallet(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_createmultisig(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_createrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_decoderawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_dumpprivkey(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_dumpwallet(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_encryptwallet(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getaccountaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getaddednodeinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getaddressesbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getbalance(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getbestblockhash(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getblockcount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getblockhash(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getblocknumber(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getblocktemplate(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getconnectioncount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getdifficulty(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getgenerate(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_gethashespersec(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getmemorypool(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getmininginfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_addmultisigaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_addnode(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_backupwallet(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_createmultisig(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_createrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_decoderawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_dumpprivkey(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_dumpwallet(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_encryptwallet(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getaccountaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getaddednodeinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getaddressesbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getbalance(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getbestblockhash(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getblockcount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getblockhash(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getblocknumber(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getblocktemplate(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getconnectioncount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getdifficulty(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getgenerate(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_gethashespersec(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getmemorypool(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getmininginfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
-void dap_chain_btc_rpc_handler_getnewaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getpeerinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getrawchangeaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getrawmempool(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getreceivedbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getreceivedbyaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_gettransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_gettxout(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_gettxoutsetinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_getwork(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_getnewaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getpeerinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getrawchangeaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getrawmempool(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getreceivedbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getreceivedbyaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_gettransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_gettxout(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_gettxoutsetinfo(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_getwork(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
-void dap_chain_btc_rpc_handler_help(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_help(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
-void dap_chain_btc_rpc_handler_importprivkey(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_invalidateblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_keypoolrefill(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listaccounts(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listaddressgroupings(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listreceivedbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_importprivkey(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_invalidateblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_keypoolrefill(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listaccounts(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listaddressgroupings(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listreceivedbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
-void dap_chain_btc_rpc_handler_listreceivedbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listreceivedbyaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listsinceblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listtransactions(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listunspent(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_listlockunspent(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_lockunspent(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_move(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_listreceivedbyaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listreceivedbyaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listsinceblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listtransactions(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listunspent(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_listlockunspent(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_lockunspent(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_move(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
-void dap_chain_btc_rpc_handler_sendfrom(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_sendmany(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_sendrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_sendtoaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_setaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_setgenerate(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_settxfee(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_signmessage(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_signrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_stop(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_submitblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_sendfrom(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_sendmany(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_sendrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_sendtoaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_setaccount(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_setgenerate(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_settxfee(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_signmessage(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_signrawtransaction(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_stop(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_submitblock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
-void dap_chain_btc_rpc_handler_validateaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_verifymessage(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_walletlock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_walletpassphrase(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
-void dap_chain_btc_rpc_handler_walletpassphrasechange(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response);
+void dap_chain_btc_rpc_handler_validateaddress(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_verifymessage(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_walletlock(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_walletpassphrase(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
+void dap_chain_btc_rpc_handler_walletpassphrasechange(dap_json_rpc_params_t *a_params, dap_json_rpc_response_t *a_response, const char *a_method);
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 462c07ef93255096bd7451fbb2561d27337fc303..753c0e627844a7cef7ea492ff263de6176e44a3b 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -110,15 +110,22 @@ typedef struct dap_chain_ledger_tx_item {
time_t ts_created;
int n_outs;
int n_outs_used;
- char token_tiker[10];
+ char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
// TODO dynamically allocates the memory in order not to limit the number of outputs in transaction
dap_chain_hash_fast_t tx_hash_spent_fast[MAX_OUT_ITEMS]; // spent outs list
} cache_data;
UT_hash_handle hh;
} dap_chain_ledger_tx_item_t;
+typedef struct dap_chain_ledger_tx_spent_item {
+ dap_chain_hash_fast_t tx_hash_fast;
+ char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
+ UT_hash_handle hh;
+} dap_chain_ledger_tx_spent_item_t;
+
+
typedef struct dap_chain_ledger_tokenizer {
- char token_ticker[10];
+ char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
uint64_t sum;
UT_hash_handle hh;
} dap_chain_ledger_tokenizer_t;
@@ -164,6 +171,7 @@ typedef struct dap_ledger_private {
dap_chain_ledger_token_emission_item_t * treshold_emissions;
dap_chain_ledger_tx_item_t *ledger_items;
+ dap_chain_ledger_tx_spent_item_t *spent_items;
dap_chain_ledger_token_item_t *tokens;
@@ -185,7 +193,7 @@ typedef struct dap_ledger_private {
dap_chain_cell_id_t local_cell_id;
/* Cache section */
dap_ledger_cache_item_t last_tx;
- dap_ledger_cache_item_t last_thres_tx;
+ dap_ledger_cache_item_t last_spent_tx;
dap_ledger_cache_item_t last_emit;
dap_ledger_cache_str_item_t last_ticker;
} dap_ledger_private_t;
@@ -272,7 +280,7 @@ void dap_chain_ledger_handle_free(dap_ledger_t *a_ledger)
void dap_chain_ledger_load_end(dap_ledger_t *a_ledger)
{
PVT(a_ledger)->last_tx.found = true;
- PVT(a_ledger)->last_thres_tx.found = true;
+ PVT(a_ledger)->last_spent_tx.found = true;
PVT(a_ledger)->last_emit.found = true;
PVT(a_ledger)->last_ticker.found = true;
}
@@ -1054,23 +1062,22 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
l_ledger_pvt->last_tx.found = true;
}
- l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_THRES_STR);
+ l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_SPENT_TXS_STR);
l_objs_count = 0;
l_objs = dap_chain_global_db_gr_load(l_gdb_group, &l_objs_count);
for (size_t i = 0; i < l_objs_count; i++) {
- dap_chain_ledger_tx_item_t *l_tx_item = DAP_NEW_Z(dap_chain_ledger_tx_item_t);
- dap_chain_hash_fast_from_str(l_objs[i].key, &l_tx_item->tx_hash_fast);
- l_tx_item->tx = DAP_NEW_SIZE(dap_chain_datum_tx_t, l_objs[i].value_len);
- memcpy(l_tx_item->tx, l_objs[i].value, l_objs[i].value_len);
- HASH_ADD(hh, l_ledger_pvt->treshold_txs, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_tx_item);
+ dap_chain_ledger_tx_spent_item_t *l_tx_spent_item = DAP_NEW_Z(dap_chain_ledger_tx_spent_item_t);
+ dap_chain_hash_fast_from_str(l_objs[i].key, &l_tx_spent_item->tx_hash_fast);
+ strncpy(l_tx_spent_item->token_ticker, (char *)l_objs[i].value, DAP_CHAIN_TICKER_SIZE_MAX);
+ HASH_ADD(hh, l_ledger_pvt->spent_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_tx_spent_item);
if (i == l_objs_count - 1) {
- l_ledger_pvt->last_thres_tx.hash = &l_tx_item->tx_hash_fast;
+ l_ledger_pvt->last_spent_tx.hash = &l_tx_spent_item->tx_hash_fast;
}
}
dap_chain_global_db_objs_delete(l_objs, l_objs_count);
DAP_DELETE(l_gdb_group);
- if (l_objs_count == 0 || l_ledger_pvt->last_thres_tx.hash == NULL) {
- l_ledger_pvt->last_thres_tx.found = true;
+ if (l_objs_count == 0 || l_ledger_pvt->last_spent_tx.hash == NULL) {
+ l_ledger_pvt->last_spent_tx.found = true;
}
l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_BALANCES_STR);
@@ -1364,13 +1371,20 @@ const char* dap_chain_ledger_tx_get_token_ticker_by_hash(dap_ledger_t *a_ledger,
if ( dap_hash_fast_is_blank(a_tx_hash) )
return NULL;
- dap_chain_ledger_tx_item_t *l_item= NULL;
+ dap_chain_ledger_tx_item_t *l_item;
pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
- HASH_FIND(hh, l_ledger_priv->ledger_items, a_tx_hash, sizeof ( *a_tx_hash), l_item );
+ HASH_FIND(hh, l_ledger_priv->ledger_items, a_tx_hash, sizeof (*a_tx_hash), l_item);
+ if (l_item) {
+ pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
+ return l_item->cache_data.token_ticker;
+ }
+ dap_chain_ledger_tx_spent_item_t *l_spent_item;
+ HASH_FIND(hh, l_ledger_priv->spent_items, a_tx_hash, sizeof (*a_tx_hash), l_spent_item);
pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
- return l_item ? l_item->cache_data.token_tiker : NULL;
+ return l_spent_item ? l_spent_item->token_ticker : NULL;
}
+
/**
* @brief dap_chain_ledger_addr_get_token_ticker_all
* @param a_addr
@@ -1394,7 +1408,7 @@ void dap_chain_ledger_addr_get_token_ticker_all(dap_ledger_t *a_ledger, dap_chai
for(size_t i = 0; i < l_tickers_size; i++) {
if (l_tickers[i]==NULL)
break;
- if(l_tickers[i] && strcmp(l_tickers[i], l_tx_item->cache_data.token_tiker) == 0) {
+ if(l_tickers[i] && strcmp(l_tickers[i], l_tx_item->cache_data.token_ticker) == 0) {
l_is_not_in_list = false;
break;
}
@@ -1404,7 +1418,7 @@ void dap_chain_ledger_addr_get_token_ticker_all(dap_ledger_t *a_ledger, dap_chai
l_tickers_size += (l_tickers_size / 2);
l_tickers = DAP_REALLOC(l_tickers, l_tickers_size);
}
- l_tickers[l_tickers_pos] = dap_strdup(l_tx_item->cache_data.token_tiker);
+ l_tickers[l_tickers_pos] = dap_strdup(l_tx_item->cache_data.token_ticker);
l_tickers_pos++;
}
dap_chain_hash_fast_t* l_tx_hash = dap_chain_node_datum_tx_calc_hash(l_tx_item->tx);
@@ -1801,7 +1815,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_token = NULL;
}
if (!l_token || !*l_token) {
- l_token = l_item_out->cache_data.token_tiker;
+ l_token = l_item_out->cache_data.token_ticker;
}
if (! l_token || !*l_token ) {
log_it(L_WARNING, "No token ticker found in previous transaction");
@@ -2148,16 +2162,6 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
pthread_rwlock_unlock(&l_ledger_priv->treshold_txs_rwlock);
if(s_debug_more)
log_it (L_DEBUG, "Tx %s added to threshold", l_tx_hash_str);
- // Add it to cache
- dap_chain_datum_tx_t *l_tx_cache = DAP_NEW_Z_SIZE(dap_chain_datum_tx_t, l_tx_size);
- memcpy(l_tx_cache, a_tx, l_tx_size);
- char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_THRES_STR);
- if (!dap_chain_global_db_gr_set(dap_strdup(l_tx_hash_str), l_tx_cache, l_tx_size, l_gdb_group)) {
- if(s_debug_more)
- log_it(L_WARNING, "Ledger cache mismatch");
- DAP_DELETE(l_tx_cache);
- }
- DAP_DELETE(l_gdb_group);
}
}
} else {
@@ -2186,8 +2190,8 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
void *l_item_in = *(void **)&bound_item->in;
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_item_in;
dap_chain_ledger_tx_item_t *l_prev_item_out = bound_item->item_out;
- l_ticker_trl = *l_prev_item_out->cache_data.token_tiker
- ? dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_tiker)
+ l_ticker_trl = *l_prev_item_out->cache_data.token_ticker
+ ? dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_ticker)
: dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext->token);
if (!l_multichannel && l_ticker_old_trl && strcmp(l_token_ticker, l_token_ticker_old)) {
l_multichannel = true;
@@ -2405,7 +2409,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
//}
}
if (l_ticker_trl && !l_multichannel)
- dap_stpcpy(l_item_tmp->cache_data.token_tiker, l_token_ticker);
+ dap_stpcpy(l_item_tmp->cache_data.token_ticker, l_token_ticker);
size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
memcpy(l_item_tmp->tx, a_tx, l_tx_size);
@@ -2424,8 +2428,8 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
DAP_DELETE(l_tx_cache);
}
DAP_DELETE(l_gdb_group);
- if (!a_from_threshold)
- s_treshold_txs_proc(a_ledger);
+ //if (!a_from_threshold)
+ // s_treshold_txs_proc(a_ledger); // TODO process thresholds only for non consensus chains
ret = 1;
}
FIN:
@@ -2435,7 +2439,7 @@ FIN:
int dap_chain_ledger_tx_load(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx)
{
- if (PVT(a_ledger)->last_tx.found && PVT(a_ledger)->last_thres_tx.found) {
+ if (PVT(a_ledger)->last_tx.found && PVT(a_ledger)->last_spent_tx.found) {
return dap_chain_ledger_tx_add(a_ledger, a_tx, false);
} else {
dap_chain_hash_fast_t l_tx_hash = {};
@@ -2444,9 +2448,9 @@ int dap_chain_ledger_tx_load(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx)
!memcmp(PVT(a_ledger)->last_tx.hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t))) {
PVT(a_ledger)->last_tx.found = true;
}
- if (!PVT(a_ledger)->last_thres_tx.found &&
- !memcmp(PVT(a_ledger)->last_thres_tx.hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t))) {
- PVT(a_ledger)->last_thres_tx.found = true;
+ if (!PVT(a_ledger)->last_spent_tx.found &&
+ !memcmp(PVT(a_ledger)->last_spent_tx.hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t))) {
+ PVT(a_ledger)->last_spent_tx.found = true;
}
}
return 1;
@@ -2466,24 +2470,38 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
dap_chain_ledger_tx_item_t *l_item_tmp;
pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
HASH_FIND(hh, l_ledger_priv->ledger_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_item_tmp);
- pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
if(l_item_tmp != NULL) {
- pthread_rwlock_wrlock(&l_ledger_priv->ledger_rwlock);
HASH_DEL(l_ledger_priv->ledger_items, l_item_tmp);
- pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
- // delete transaction
- DAP_DELETE(l_item_tmp->tx);
- // del struct for hash
- DAP_DELETE(l_item_tmp);
// Remove it from cache
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_STR);
dap_chain_global_db_gr_del(dap_chain_hash_fast_to_str_new(a_tx_hash), l_gdb_group);
DAP_DELETE(l_gdb_group);
l_ret = 1;
+ dap_chain_ledger_tx_spent_item_t *l_item_used;
+ HASH_FIND(hh, l_ledger_priv->spent_items, a_tx_hash, sizeof(dap_chain_hash_fast_t), l_item_used);
+ if (!l_item_used) { // Add it to spent items
+ l_item_used = DAP_NEW_Z(dap_chain_ledger_tx_spent_item_t);
+ memcpy(&l_item_used->tx_hash_fast, a_tx_hash, sizeof(dap_chain_hash_fast_t));
+ strncpy(l_item_used->token_ticker, l_item_tmp->cache_data.token_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
+ HASH_ADD(hh, l_ledger_priv->spent_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_item_used);
+ // Add it to cache
+ char *l_cache_data = DAP_NEW_Z_SIZE(char, DAP_CHAIN_TICKER_SIZE_MAX);
+ strncpy(l_cache_data, l_item_used->token_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
+ l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_SPENT_TXS_STR);
+ if (!dap_chain_global_db_gr_set(dap_hash_fast_to_str_new(a_tx_hash), l_cache_data, -1, l_gdb_group)) {
+ if(s_debug_more)
+ log_it(L_WARNING, "Ledger cache mismatch");
+ DAP_DELETE(l_cache_data);
+ }
+ DAP_DELETE(l_gdb_group);
+ }
+ // del struct for hash
+ DAP_DELETE(l_item_tmp);
}
else
// hash not found in the cache
l_ret = -2;
+ pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
return l_ret;
}
@@ -2515,15 +2533,15 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
}
DAP_DELETE(l_gdb_group);
- // delete threshold txs
- l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TXS_THRES_STR);
- HASH_ITER(hh, l_ledger_priv->treshold_txs, l_item_current, l_item_tmp) {
- HASH_DEL(l_ledger_priv->treshold_txs, l_item_current);
+ // delete spent transactions
+ dap_chain_ledger_tx_spent_item_t *l_spent_item_current, *l_spent_item_tmp;
+ l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_SPENT_TXS_STR);
+ HASH_ITER(hh, l_ledger_priv->spent_items, l_spent_item_current, l_spent_item_tmp) {
+ HASH_DEL(l_ledger_priv->spent_items, l_spent_item_current);
if (!a_preserve_db) {
- dap_chain_hash_fast_to_str(&l_item_current->tx_hash_fast, l_hash_str, l_hash_str_size);
+ dap_chain_hash_fast_to_str(&l_spent_item_current->tx_hash_fast, l_hash_str, l_hash_str_size);
dap_chain_global_db_gr_del(dap_strdup(l_hash_str), l_gdb_group);
}
- DAP_DELETE(l_item_current->tx);
DAP_DELETE(l_item_current);
}
DAP_DELETE(l_gdb_group);
@@ -2531,6 +2549,7 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
// delete balances
dap_ledger_wallet_balance_t *l_balance_current, *l_balance_tmp;
l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_BALANCES_STR);
+ char *l_emissions_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_EMISSIONS_STR);
HASH_ITER(hh, l_ledger_priv->balance_accounts, l_balance_current, l_balance_tmp) {
HASH_DEL(l_ledger_priv->balance_accounts, l_balance_current);
if (!a_preserve_db)
@@ -2539,21 +2558,9 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
}
DAP_DELETE(l_gdb_group);
- // delete threshold emissions
- dap_chain_ledger_token_emission_item_t *l_emission_current, *l_emission_tmp;
- char *l_emissions_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_EMISSIONS_STR);
- HASH_ITER(hh, l_ledger_priv->treshold_emissions, l_emission_current, l_emission_tmp) {
- HASH_DEL(l_ledger_priv->treshold_emissions, l_emission_current);
- if (!a_preserve_db) {
- dap_chain_hash_fast_to_str(&l_emission_current->datum_token_emission_hash, l_hash_str, l_hash_str_size);
- dap_chain_global_db_gr_del(dap_strdup(l_hash_str), l_emissions_gdb_group);
- }
- DAP_DELETE(l_emission_current->datum_token_emission);
- DAP_DELETE(l_emission_current);
- }
-
// delete tokens & its emissions
dap_chain_ledger_token_item_t *l_token_current, *l_token_tmp;
+ dap_chain_ledger_token_emission_item_t *l_emission_current, *l_emission_tmp;
l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TOKENS_STR);
HASH_ITER(hh, l_ledger_priv->tokens, l_token_current, l_token_tmp) {
HASH_DEL(l_ledger_priv->tokens, l_token_current);
@@ -2573,12 +2580,26 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
DAP_DELETE(l_token_current->datum_token);
pthread_rwlock_destroy(&l_token_current->token_emissions_rwlock);
DAP_DELETE(l_token_current);
- }
+ }
DAP_DELETE(l_gdb_group);
DAP_DELETE(l_emissions_gdb_group);
+
+ // delete threshold emissions
+ HASH_ITER(hh, l_ledger_priv->treshold_emissions, l_emission_current, l_emission_tmp) {
+ HASH_DEL(l_ledger_priv->treshold_emissions, l_emission_current);
+ DAP_DELETE(l_emission_current->datum_token_emission);
+ DAP_DELETE(l_emission_current);
+ }
+ // delete threshold transactions
+ HASH_ITER(hh, l_ledger_priv->treshold_txs, l_item_current, l_item_tmp) {
+ HASH_DEL(l_ledger_priv->treshold_txs, l_item_current);
+ DAP_DELETE(l_item_current->tx);
+ DAP_DELETE(l_item_current);
+ }
+
l_ledger_priv->last_tx.found = true;
- l_ledger_priv->last_thres_tx.found = true;
+ l_ledger_priv->last_spent_tx.found = true;
l_ledger_priv->last_emit.found = true;
l_ledger_priv->last_ticker.found = true;
@@ -2733,7 +2754,7 @@ uint128_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
if (l_type == TX_ITEM_TYPE_OUT) {
const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
// Check for token name
- if (!strcmp(a_token_ticker, l_iter_current->cache_data.token_tiker))
+ if (!strcmp(a_token_ticker, l_iter_current->cache_data.token_ticker))
{ // if transaction has the out item with requested addr
if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
// if 'out' item not used & transaction is valid
@@ -2789,8 +2810,8 @@ static dap_chain_ledger_tx_item_t* tx_item_find_by_addr(dap_ledger_t *a_ledger,
HASH_ITER(hh, l_ledger_priv->ledger_items , l_iter_current, l_item_tmp)
{
// If a_token is setup we check if its not our token - miss it
- if (a_token && *l_iter_current->cache_data.token_tiker &&
- dap_strcmp(l_iter_current->cache_data.token_tiker, a_token))
+ if (a_token && *l_iter_current->cache_data.token_ticker &&
+ dap_strcmp(l_iter_current->cache_data.token_ticker, a_token))
continue;
// Now work with it
dap_chain_datum_tx_t *l_tx = l_iter_current->tx;
@@ -2946,7 +2967,7 @@ dap_chain_datum_tx_t* dap_chain_ledger_tx_cache_find_out_cond(dap_ledger_t *a_le
l_cur_tx = l_tx_tmp;
memcpy(a_tx_first_hash, l_tx_hash_tmp, sizeof(dap_chain_hash_fast_t));
if (a_token_ticker) {
- strcpy(a_token_ticker, l_iter_current->cache_data.token_tiker);
+ strcpy(a_token_ticker, l_iter_current->cache_data.token_ticker);
}
break;
}
diff --git a/modules/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index 5d6de24f6666dfe727b6770e097da2ac02b0669a..4a979ea82bc6b7433364d816963f63fcd64d04fb 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -75,7 +75,7 @@ typedef dap_chain_atom_iter_t* (*dap_chain_callback_atom_iter_create_from_t)(dap
typedef dap_chain_atom_ptr_t (*dap_chain_callback_atom_iter_get_first_t)(dap_chain_atom_iter_t * , size_t*);
typedef dap_chain_datum_t** (*dap_chain_callback_atom_get_datum_t)(dap_chain_atom_ptr_t, size_t, size_t * );
typedef dap_chain_atom_ptr_t (*dap_chain_callback_atom_iter_find_by_hash_t)(dap_chain_atom_iter_t * ,dap_chain_hash_fast_t *,size_t*);
-typedef dap_chain_datum_tx_t* (*dap_chain_callback_tx_find_by_hash_t)(dap_chain_t * ,dap_chain_hash_fast_t *);
+typedef dap_chain_datum_tx_t* (*dap_chain_callback_tx_find_by_hash_t)(dap_chain_t *, dap_chain_hash_fast_t *);
typedef dap_chain_atom_ptr_t * (*dap_chain_callback_atom_iter_get_atoms_t)(dap_chain_atom_iter_t * ,size_t* ,size_t**);
diff --git a/modules/chain/include/dap_chain_ledger.h b/modules/chain/include/dap_chain_ledger.h
index d1d22d3efc9431fdc8dee52b039c6f6044817971..13892ffc3fc2fadf301b16e66f22e54387554fb7 100644
--- a/modules/chain/include/dap_chain_ledger.h
+++ b/modules/chain/include/dap_chain_ledger.h
@@ -63,7 +63,8 @@ typedef bool (* dap_chain_ledger_verificator_callback_t)(dap_chain_tx_out_cond_t
#define DAP_CHAIN_LEDGER_TOKENS_STR "tokens"
#define DAP_CHAIN_LEDGER_EMISSIONS_STR "emissions"
#define DAP_CHAIN_LEDGER_TXS_STR "txs"
-#define DAP_CHAIN_LEDGER_TXS_THRES_STR "thres_txs"
+#define DAP_CHAIN_LEDGER_TXS_THRES_STR "thres_txs" // obsolete
+#define DAP_CHAIN_LEDGER_SPENT_TXS_STR "spent_txs"
#define DAP_CHAIN_LEDGER_BALANCES_STR "balances"
int dap_chain_ledger_init();
diff --git a/modules/global-db/dap_chain_global_db_driver_sqlite.c b/modules/global-db/dap_chain_global_db_driver_sqlite.c
index a234a7061507af93dd8b075129ba094ea340db37..4d9343e1e25fc748a568206d5bdcc5bbe79880c3 100644
--- a/modules/global-db/dap_chain_global_db_driver_sqlite.c
+++ b/modules/global-db/dap_chain_global_db_driver_sqlite.c
@@ -839,12 +839,13 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
if(a_count_out)
l_count_out = (int)*a_count_out;
char *l_str_query = NULL;
- if(l_count_out)
+ if (l_count_out) {
l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE id>='%lld' ORDER BY id ASC LIMIT %d",
l_table_name, a_id, l_count_out);
- else
+ } else {
l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE id>='%lld' ORDER BY id ASC",
l_table_name, a_id);
+ }
sqlite3 *s_db = s_sqlite_get_connection();
if(!s_db){
if (l_str_query) sqlite3_free(l_str_query);
@@ -917,20 +918,22 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
if(a_count_out)
l_count_out = *a_count_out;
char *l_str_query;
- if(a_key) {
- if(l_count_out)
+ if (a_key) {
+ if (l_count_out) {
l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE key='%s' ORDER BY id ASC LIMIT %d",
l_table_name, a_key, l_count_out);
- else
+ } else {
l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE key='%s' ORDER BY id ASC",
l_table_name, a_key);
+ }
}
else {
- if(l_count_out)
+ if (l_count_out) {
l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' ORDER BY id ASC LIMIT %d",
l_table_name, l_count_out);
- else
+ } else {
l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' ORDER BY id ASC", l_table_name);
+ }
}
int l_ret = dap_db_driver_sqlite_query(s_db, l_str_query, &l_res, NULL);
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index f5648db51df4f49f5987190ae1ca9dc5829a9c0f..700ada9e0322748a51add97389a574c36be3e782 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -124,6 +124,11 @@ struct link_dns_request {
uint_fast16_t tries;
};
+struct net_link {
+ dap_chain_node_info_t *link_info;
+ dap_chain_node_client_t *link;
+};
+
/**
* @struct dap_chain_net_pvt
* @details Private part of chain_net dap object
@@ -147,12 +152,9 @@ typedef struct dap_chain_net_pvt{
//Active synchronizing link
dap_chain_node_client_t *active_link;
- // Established links
- dap_list_t *links; // Links list
- size_t links_connected_count;
- // Prepared links
- dap_list_t *links_info; // Links info list
+ dap_list_t *net_links; // Links list
+ size_t links_connected_count;
atomic_uint links_dns_requests;
@@ -241,6 +243,9 @@ static void s_net_links_notify(dap_chain_net_t * a_net );
static void s_net_state_link_prepare_success(dap_worker_t * a_worker,dap_chain_node_info_t * a_node_info, void * a_arg);
static void s_net_state_link_prepare_error(dap_worker_t * a_worker,dap_chain_node_info_t * a_node_info, void * a_arg, int a_errno);
+// Replace link success/error callbacks
+static void s_net_state_link_replace_success(dap_worker_t *a_worker,dap_chain_node_info_t *a_node_info, void *a_arg);
+static void s_net_state_link_replace_error(dap_worker_t *a_worker,dap_chain_node_info_t *a_node_info, void *a_arg, int a_errno);
//static void s_net_proc_kill( dap_chain_net_t * a_net );
int s_net_load(const char * a_net_name, uint16_t a_acl_idx);
@@ -426,8 +431,10 @@ void dap_chain_net_sync_gdb_broadcast(void *a_arg, const char a_op_code, const c
dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_net, "gdb");
dap_chain_id_t l_chain_id = l_chain ? l_chain->id : (dap_chain_id_t) {};
pthread_rwlock_rdlock(&PVT(l_net)->rwlock);
- for (dap_list_t *l_tmp = PVT(l_net)->links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
- dap_chain_node_client_t *l_node_client = (dap_chain_node_client_t *)l_tmp->data;
+ for (dap_list_t *l_tmp = PVT(l_net)->net_links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
+ dap_chain_node_client_t *l_node_client = ((struct net_link *)l_tmp->data)->link;
+ if (!l_node_client)
+ continue;
dap_stream_worker_t *l_stream_worker = dap_client_get_stream_worker(l_node_client->client);
if (l_stream_worker)
continue;
@@ -476,17 +483,57 @@ static void s_chain_callback_notify(void * a_arg, dap_chain_t *a_chain, dap_chai
dap_chain_net_t *l_net = (dap_chain_net_t *)a_arg;
if (PVT(l_net)->state == NET_STATE_ONLINE) {
pthread_rwlock_rdlock(&PVT(l_net)->rwlock);
- for (dap_list_t *l_tmp = PVT(l_net)->links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
- dap_chain_node_client_t *l_node_client = (dap_chain_node_client_t *)l_tmp->data;
- dap_stream_worker_t * l_worker = dap_client_get_stream_worker( l_node_client->client);
- if(l_worker)
- dap_stream_ch_chain_pkt_write_mt(l_worker, l_node_client->ch_chain_uuid, DAP_STREAM_CH_CHAIN_PKT_TYPE_CHAIN,
- l_net->pub.id.uint64, a_chain->id.uint64, a_id.uint64, a_atom, a_atom_size);
+ for (dap_list_t *l_tmp = PVT(l_net)->net_links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
+ dap_chain_node_client_t *l_node_client = ((struct net_link *)l_tmp->data)->link;
+ if (l_node_client) {
+ dap_stream_worker_t * l_worker = dap_client_get_stream_worker( l_node_client->client);
+ if(l_worker)
+ dap_stream_ch_chain_pkt_write_mt(l_worker, l_node_client->ch_chain_uuid, DAP_STREAM_CH_CHAIN_PKT_TYPE_CHAIN,
+ l_net->pub.id.uint64, a_chain->id.uint64, a_id.uint64, a_atom, a_atom_size);
+ }
}
pthread_rwlock_unlock(&PVT(l_net)->rwlock);
}
}
+static dap_chain_node_info_t *s_get_dns_link_from_cfg(dap_chain_net_t *a_net)
+{
+ dap_chain_net_pvt_t *l_net_pvt = PVT(a_net);
+ struct in_addr l_addr = {};
+ uint16_t i, l_port;
+ if (l_net_pvt->seed_aliases_count) {
+ i = rand() % l_net_pvt->seed_aliases_count;
+ dap_chain_node_addr_t *l_remote_addr = dap_chain_node_alias_find(a_net, l_net_pvt->seed_aliases[i]);
+ if (l_remote_addr){
+ dap_chain_node_info_t *l_remote_node_info = dap_chain_node_info_read(a_net, l_remote_addr);
+ if(l_remote_node_info){
+ l_addr.s_addr = l_remote_node_info ? l_remote_node_info->hdr.ext_addr_v4.s_addr : 0;
+ DAP_DELETE(l_remote_node_info);
+ l_port = DNS_LISTEN_PORT;
+ }else{
+ log_it(L_WARNING,"Can't find node info for node addr "NODE_ADDR_FP_STR,
+ NODE_ADDR_FP_ARGS(l_remote_addr));
+ }
+ }else{
+ log_it(L_WARNING,"Can't find alias info for seed alias %s",l_net_pvt->seed_aliases[i]);
+ }
+ } else if (l_net_pvt->bootstrap_nodes_count) {
+ i = rand() % l_net_pvt->bootstrap_nodes_count;
+ l_addr = l_net_pvt->bootstrap_nodes_addrs[i];
+ l_port = l_net_pvt->bootstrap_nodes_ports[i];
+ }
+ if (!l_addr.s_addr)
+ return NULL;
+ dap_chain_node_info_t *l_link_node_info = DAP_NEW_Z(dap_chain_node_info_t);
+ if(! l_link_node_info){
+ log_it(L_CRITICAL,"Can't allocate memory for node link info");
+ return NULL;
+ }
+ l_link_node_info->hdr.ext_addr_v4 = l_addr;
+ l_link_node_info->hdr.ext_port = l_port;
+ return l_link_node_info;
+}
+
/**
* @brief s_fill_links_from_root_aliases
* @param a_net
@@ -497,7 +544,7 @@ static void s_fill_links_from_root_aliases(dap_chain_net_t * a_net)
uint64_t l_own_addr = dap_chain_net_get_cur_addr_int(a_net);
for (size_t i = 0; i < MIN(s_max_links_count, l_pvt_net->seed_aliases_count); i++) {
pthread_rwlock_rdlock(&l_pvt_net->rwlock);
- if (dap_list_length(l_pvt_net->links_info) >= s_max_links_count) {
+ if (dap_list_length(l_pvt_net->net_links) >= s_max_links_count) {
pthread_rwlock_unlock(&l_pvt_net->rwlock);
break;
}else
@@ -512,8 +559,10 @@ static void s_fill_links_from_root_aliases(dap_chain_net_t * a_net)
}
dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(a_net, l_link_addr);
if(l_link_node_info) {
+ struct net_link *l_new_link = DAP_NEW_Z(struct net_link);
+ l_new_link->link_info = l_link_node_info;
pthread_rwlock_wrlock(&l_pvt_net->rwlock);
- l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
+ l_pvt_net->net_links = dap_list_append(l_pvt_net->net_links, l_new_link);
pthread_rwlock_unlock(&l_pvt_net->rwlock);
} else {
log_it(L_WARNING, "Not found link %s."NODE_ADDR_FP_STR" in the node list", a_net->pub.name,
@@ -522,6 +571,94 @@ static void s_fill_links_from_root_aliases(dap_chain_net_t * a_net)
}
}
+/**
+ * @brief s_net_state_link_replace_error
+ * @param a_worker
+ * @param a_node_info
+ * @param a_arg
+ * @param a_errno
+ */
+static void s_net_state_link_replace_error(dap_worker_t *a_worker, dap_chain_node_info_t *a_node_info, void *a_arg, int a_errno)
+{
+ UNUSED(a_worker);
+ struct link_dns_request *l_dns_request = (struct link_dns_request *)a_arg;
+ dap_chain_net_t *l_net = l_dns_request->net;
+ char l_node_addr_str[INET_ADDRSTRLEN] = {};
+ inet_ntop(AF_INET, &a_node_info->hdr.ext_addr_v4, l_node_addr_str, sizeof (a_node_info->hdr.ext_addr_v4));
+ log_it(L_WARNING,"Link " NODE_ADDR_FP_STR " (%s) replace error with code %d", NODE_ADDR_FP_ARGS_S(a_node_info->hdr.address),
+ l_node_addr_str,a_errno );
+ dap_notify_server_send_f_mt("{"
+ "class:\"NetLinkReplaceError\","
+ "net_id:0x%016" DAP_UINT64_FORMAT_X ","
+ "cell_id:0x%016"DAP_UINT64_FORMAT_X","
+ "address:\""NODE_ADDR_FP_STR"\","
+ "error: %d"
+ "}\n", l_net->pub.id.uint64, a_node_info->hdr.cell_id.uint64,
+ NODE_ADDR_FP_ARGS_S(a_node_info->hdr.address), a_errno);
+ DAP_DELETE(a_node_info);
+ dap_chain_node_info_t *l_link_node_info = NULL;
+ for (int i = 0; i < 1000; i++) {
+ l_link_node_info = s_get_dns_link_from_cfg(l_net);
+ if (l_link_node_info)
+ break;
+ }
+ if (!l_link_node_info) { // We have lost this link forever
+ DAP_DELETE(l_dns_request);
+ return;
+ }
+ if (dap_chain_node_info_dns_request(l_link_node_info->hdr.ext_addr_v4,
+ l_link_node_info->hdr.ext_port,
+ l_net->pub.name,
+ l_link_node_info, // use it twice
+ s_net_state_link_replace_success,
+ s_net_state_link_replace_error,
+ l_dns_request)) {
+ log_it(L_ERROR, "Can't process node info dns request");
+ DAP_DELETE(l_link_node_info);
+ DAP_DELETE(l_dns_request);
+ }
+}
+
+/**
+ * @brief s_net_state_link_repace_success
+ * @param a_worker
+ * @param a_node_info
+ * @param a_arg
+ */
+static void s_net_state_link_replace_success(dap_worker_t *a_worker, dap_chain_node_info_t *a_node_info, void *a_arg)
+{
+ if (s_debug_more) {
+ char l_node_addr_str[INET_ADDRSTRLEN] = {};
+ inet_ntop(AF_INET, &a_node_info->hdr.ext_addr_v4, l_node_addr_str, INET_ADDRSTRLEN);
+ log_it(L_DEBUG,"Link " NODE_ADDR_FP_STR " (%s) replace success", NODE_ADDR_FP_ARGS_S(a_node_info->hdr.address),
+ l_node_addr_str);
+ }
+
+ struct link_dns_request *l_dns_request = (struct link_dns_request *)a_arg;
+ dap_chain_net_t *l_net = l_dns_request->net;
+ dap_chain_net_pvt_t *l_net_pvt = PVT(l_net);
+ uint64_t l_own_addr = dap_chain_net_get_cur_addr_int(l_net);
+ if (a_node_info->hdr.address.uint64 == l_own_addr) {
+ s_net_state_link_replace_error(a_worker, a_node_info, a_arg, EWOULDBLOCK);
+ return;
+ }
+ struct net_link *l_new_link = DAP_NEW_Z(struct net_link);
+ l_new_link->link_info = a_node_info;
+ l_new_link->link = dap_chain_net_client_create_n_connect(l_net, a_node_info);
+ pthread_rwlock_wrlock(&l_net_pvt->rwlock);
+ l_net_pvt->net_links = dap_list_append(l_net_pvt->net_links, l_new_link);
+ pthread_rwlock_unlock(&l_net_pvt->rwlock);
+
+ dap_notify_server_send_f_mt("{"
+ "class:\"NetLinkReplaceSuccess\","
+ "net_id:0x%016" DAP_UINT64_FORMAT_X ","
+ "cell_id:0x%016"DAP_UINT64_FORMAT_X","
+ "address:\""NODE_ADDR_FP_STR"\""
+ "}\n", l_net->pub.id.uint64, a_node_info->hdr.cell_id.uint64,
+ NODE_ADDR_FP_ARGS_S(a_node_info->hdr.address));
+ DAP_DELETE(l_dns_request);
+}
+
/**
* @brief s_node_link_callback_connected
* @param a_node_client
@@ -555,28 +692,69 @@ static void s_node_link_callback_connected(dap_chain_node_client_t * a_node_clie
}
+static void s_node_link_remove(dap_chain_net_pvt_t *a_net_pvt, dap_chain_node_client_t *a_node_client)
+{
+ for (dap_list_t *it = a_net_pvt->net_links; it; it = it->next) {
+ if (((struct net_link *)it->data)->link == a_node_client) {
+ DAP_DELETE(((struct net_link *)it->data)->link_info);
+ a_net_pvt->net_links = dap_list_delete_link(a_net_pvt->net_links, it);
+ break;
+ }
+ }
+}
+
/**
* @brief s_node_link_callback_disconnected
* @param a_node_client
* @param a_arg
*/
-static void s_node_link_callback_disconnected(dap_chain_node_client_t * a_node_client, void * a_arg)
+static void s_node_link_callback_disconnected(dap_chain_node_client_t *a_node_client, void * a_arg)
{
- dap_chain_net_t * l_net = (dap_chain_net_t *) a_arg;
- dap_chain_net_pvt_t * l_net_pvt = PVT(l_net);
+ dap_chain_net_t *l_net = (dap_chain_net_t *)a_arg;
+ dap_chain_net_pvt_t *l_net_pvt = PVT(l_net);
pthread_rwlock_wrlock(&l_net_pvt->rwlock);
if (a_node_client->is_connected) {
a_node_client->is_connected = false;
log_it(L_INFO, "%s."NODE_ADDR_FP_STR" disconnected.%s",l_net->pub.name,
NODE_ADDR_FP_ARGS_S(a_node_client->info->hdr.address),
- l_net_pvt->state_target == NET_STATE_OFFLINE ? "" : " Reconnecting back...");
+ l_net_pvt->state_target == NET_STATE_OFFLINE ? "" : " Replace it...");
if (l_net_pvt->links_connected_count)
l_net_pvt->links_connected_count--;
else
log_it(L_ERROR, "Links count is zero in disconnected callback, looks smbd decreased it twice or forget to increase on connect/reconnect");
}
if (l_net_pvt->state_target != NET_STATE_OFFLINE) {
- a_node_client->keep_connection = true;
+ for (dap_list_t *it = l_net_pvt->net_links; it; it = it->next) {
+ if (((struct net_link *)it->data)->link == NULL) { // We have a free prepared link
+ s_node_link_remove(l_net_pvt, a_node_client);
+ ((struct net_link *)it->data)->link = dap_chain_net_client_create_n_connect(l_net,
+ ((struct net_link *)it->data)->link_info);
+ pthread_rwlock_unlock(&l_net_pvt->rwlock);
+ return;
+ }
+ }
+ dap_chain_node_info_t *l_link_node_info = s_get_dns_link_from_cfg(l_net);
+ if (!l_link_node_info) { // Try to keep this connection
+ a_node_client->keep_connection = true;
+ } else {
+ struct link_dns_request *l_dns_request = DAP_NEW_Z(struct link_dns_request);
+ l_dns_request->net = l_net;
+ if (dap_chain_node_info_dns_request(l_link_node_info->hdr.ext_addr_v4,
+ l_link_node_info->hdr.ext_port,
+ l_net->pub.name,
+ l_link_node_info, // use it twice
+ s_net_state_link_replace_success,
+ s_net_state_link_replace_error,
+ l_dns_request)) {
+ log_it(L_ERROR, "Can't process node info dns request");
+ DAP_DELETE(l_link_node_info);
+ DAP_DELETE(l_dns_request);
+ a_node_client->keep_connection = true;
+ } else {
+ s_node_link_remove(l_net_pvt, a_node_client);
+ a_node_client->keep_connection = false;
+ }
+ }
}
pthread_rwlock_unlock(&l_net_pvt->rwlock);
}
@@ -646,10 +824,10 @@ static void s_node_link_callback_delete(dap_chain_node_client_t * a_node_client,
return;
}
pthread_rwlock_wrlock(&l_net_pvt->rwlock);
- for ( dap_list_t * it = l_net_pvt->links; it; it=it->next ){
- if (it->data == a_node_client) {
+ for ( dap_list_t * it = l_net_pvt->net_links; it; it=it->next ){
+ if (((struct net_link *)it->data)->link == a_node_client) {
log_it(L_DEBUG,"Replace node client with new one");
- it->data = dap_chain_net_client_create_n_connect(l_net, a_node_client->info);
+ ((struct net_link *)it->data)->link = dap_chain_net_client_create_n_connect(l_net, a_node_client->info);
}
}
pthread_rwlock_unlock(&l_net_pvt->rwlock);
@@ -681,10 +859,12 @@ static void s_net_state_link_prepare_success(dap_worker_t * a_worker,dap_chain_n
struct link_dns_request * l_dns_request = (struct link_dns_request *) a_arg;
dap_chain_net_t * l_net = l_dns_request->net;
dap_chain_net_pvt_t * l_net_pvt = PVT(l_net);
- uint64_t l_own_addr =0;
+ uint64_t l_own_addr = dap_chain_net_get_cur_addr_int(l_net);
if (a_node_info->hdr.address.uint64 != l_own_addr) {
+ struct net_link *l_new_link = DAP_NEW_Z(struct net_link);
+ l_new_link->link_info = a_node_info;
pthread_rwlock_wrlock(&l_net_pvt->rwlock);
- l_net_pvt->links_info = dap_list_append(l_net_pvt->links_info, a_node_info);
+ l_net_pvt->net_links = dap_list_append(l_net_pvt->net_links, l_new_link);
pthread_rwlock_unlock(&l_net_pvt->rwlock);
l_dns_request->tries = 0;
}
@@ -781,8 +961,8 @@ static void s_net_links_notify(dap_chain_net_t * a_net )
dap_string_t * l_str_reply = dap_string_new("[");
size_t i =0;
- for (dap_list_t * l_item = l_net_pvt->links; l_item; l_item = l_item->next ) {
- dap_chain_node_client_t * l_node_client = l_item->data;
+ for (dap_list_t * l_item = l_net_pvt->net_links; l_item; l_item = l_item->next ) {
+ dap_chain_node_client_t * l_node_client = ((struct net_link *)l_item->data)->link;
if(l_node_client){
dap_chain_node_info_t * l_info = l_node_client->info;
@@ -841,19 +1021,19 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
case NET_STATE_OFFLINE: {
// delete all links
l_net_pvt->links_connected_count = 0;
- dap_list_t *l_tmp = l_net_pvt->links;
+ dap_list_t *l_tmp = l_net_pvt->net_links;
while (l_tmp) {
dap_list_t *l_next = l_tmp->next;
- ((dap_chain_node_client_t *)l_tmp->data)->keep_connection = false;
- dap_chain_node_client_close(l_tmp->data);
+ dap_chain_node_client_t *l_link = ((struct net_link *)l_tmp->data)->link;
+ if (l_link) {
+ l_link->keep_connection = false;
+ dap_chain_node_client_close(l_link);
+ }
+ DAP_DELETE(((struct net_link *)l_tmp->data)->link_info);
DAP_DELETE(l_tmp);
l_tmp = l_next;
}
- l_net_pvt->links = NULL;
- if(l_net_pvt->links_info){
- dap_list_free_full(l_net_pvt->links_info, free);
- l_net_pvt->links_info = NULL;
- }
+ l_net_pvt->net_links = NULL;
if ( l_net_pvt->state_target != NET_STATE_OFFLINE ){
l_net_pvt->state = NET_STATE_LINKS_PREPARE;
l_repeat_after_exit = true;
@@ -876,7 +1056,9 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
l_link_node_info->hdr.address.uint64 = l_net_pvt->gdb_sync_nodes_addrs[i].uint64;
l_link_node_info->hdr.ext_addr_v4.s_addr = l_net_pvt->gdb_sync_nodes_links_ips[i];
l_link_node_info->hdr.ext_port = l_net_pvt->gdb_sync_nodes_links_ports[i];
- l_net_pvt->links_info = dap_list_append(l_net_pvt->links_info, l_link_node_info);
+ struct net_link *l_new_link = DAP_NEW_Z(struct net_link);
+ l_new_link->link_info = l_link_node_info;
+ l_net_pvt->net_links = dap_list_append(l_net_pvt->net_links, l_new_link);
}
uint64_t l_own_addr = dap_chain_net_get_cur_addr_int(l_net);
if (l_net_pvt->node_info) {
@@ -885,8 +1067,10 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
if (!l_link_node_info || l_link_node_info->hdr.address.uint64 == l_own_addr) {
continue; // Do not link with self
}
- l_net_pvt->links_info = dap_list_append(l_net_pvt->links_info, l_link_node_info);
- if (dap_list_length(l_net_pvt->links_info) >= s_max_links_count) {
+ struct net_link *l_new_link = DAP_NEW_Z(struct net_link);
+ l_new_link->link_info = l_link_node_info;
+ l_net_pvt->net_links = dap_list_append(l_net_pvt->net_links, l_new_link);
+ if (dap_list_length(l_net_pvt->net_links) >= s_max_links_count) {
break;
}
}
@@ -912,73 +1096,42 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
case NODE_ROLE_MASTER:
case NODE_ROLE_LIGHT:
default: {
+ if (!l_net_pvt->seed_aliases_count && ! l_net_pvt->bootstrap_nodes_count){
+ log_it(L_ERROR, "No root servers present in configuration file. Can't establish DNS requests");
+ if (l_net_pvt->net_links) { // We have other links
+ l_net_pvt->state = NET_STATE_LINKS_CONNECTING;
+ l_repeat_after_exit = true;
+ }
+ break;
+ }
// Get DNS request result from root nodes as synchronization links
bool l_sync_fill_root_nodes = false;
- uint32_t l_link_id=0;
- if (!l_sync_fill_root_nodes){
- for (size_t n=0; n< s_required_links_count;n++ ) {
- struct in_addr l_addr = {};
- uint16_t i, l_port;
- if (l_net_pvt->seed_aliases_count) {
- i = rand() % l_net_pvt->seed_aliases_count;
- dap_chain_node_addr_t *l_remote_addr = dap_chain_node_alias_find(l_net, l_net_pvt->seed_aliases[i]);
- if (l_remote_addr){
- dap_chain_node_info_t *l_remote_node_info = dap_chain_node_info_read(l_net, l_remote_addr);
- if(l_remote_node_info){
- l_addr.s_addr = l_remote_node_info ? l_remote_node_info->hdr.ext_addr_v4.s_addr : 0;
- DAP_DELETE(l_remote_node_info);
- l_port = DNS_LISTEN_PORT;
- }else{
- log_it(L_WARNING,"Can't find node info for node addr "NODE_ADDR_FP_STR,
- NODE_ADDR_FP_ARGS(l_remote_addr));
- }
- }else{
- log_it(L_WARNING,"Can't find alias info for seed alias %s",l_net_pvt->seed_aliases[i]);
- }
- } else if (l_net_pvt->bootstrap_nodes_count) {
- i = rand() % l_net_pvt->bootstrap_nodes_count;
- l_addr = l_net_pvt->bootstrap_nodes_addrs[i];
- l_port = l_net_pvt->bootstrap_nodes_ports[i];
- } else {
- log_it(L_ERROR, "No root servers present in configuration file. Can't establish DNS requests");
- if (!dap_list_length(l_net_pvt->links_info)) { // No links can be prepared, go offline
- l_net_pvt->state_target = NET_STATE_OFFLINE;
- }
- }
- if (l_addr.s_addr) {
- dap_chain_node_info_t *l_link_node_info = DAP_NEW_Z(dap_chain_node_info_t);
- if(! l_link_node_info){
- log_it(L_CRITICAL,"Can't allocate memory for node link info");
- break;
- }
-/* #ifdef DAP_OS_UNIX
- struct in_addr _in_addr = { .s_addr = l_addr.s_addr };
- #else
- struct in_addr _in_addr = { { .S_addr = l_addr.S_un.S_addr } };
- #endif
-*/
- l_sync_fill_root_nodes = false;
- if (l_net_pvt->state_target != NET_STATE_OFFLINE) {
- l_net_pvt->links_dns_requests++;
- struct link_dns_request * l_dns_request = DAP_NEW_Z(struct link_dns_request);
- l_dns_request->net = l_net;
- l_dns_request->link_id = l_link_id;
- if(dap_chain_node_info_dns_request(l_addr, l_port, l_net->pub.name, l_link_node_info,
- s_net_state_link_prepare_success,
- s_net_state_link_prepare_error,l_dns_request) != 0 ){
- log_it(L_ERROR, "Can't process node info dns request");
- DAP_DEL_Z(l_link_node_info);
-
- }
- }else{
- DAP_DEL_Z(l_link_node_info);
- }
+ uint32_t l_link_id = 0;
+ if (!l_sync_fill_root_nodes) {
+ for (size_t n = 0; l_net_pvt->links_dns_requests < s_max_links_count; n++) {
+ dap_chain_node_info_t *l_link_node_info = s_get_dns_link_from_cfg(l_net);
+ if (!l_link_node_info)
+ continue;
+ l_net_pvt->links_dns_requests++;
+ struct link_dns_request *l_dns_request = DAP_NEW_Z(struct link_dns_request);
+ l_dns_request->net = l_net;
+ l_dns_request->link_id = l_link_id++;
+ if (dap_chain_node_info_dns_request(l_link_node_info->hdr.ext_addr_v4,
+ l_link_node_info->hdr.ext_port,
+ l_net->pub.name,
+ l_link_node_info, // use it twice
+ s_net_state_link_prepare_success,
+ s_net_state_link_prepare_error,
+ l_dns_request)) {
+ log_it(L_ERROR, "Can't process node info dns request");
+ DAP_DEL_Z(l_dns_request);
+ DAP_DEL_Z(l_link_node_info);
}
- l_link_id++;
+ if (n > 1000) // It's a problem with link prepare
+ break;
}
- }
- if (l_sync_fill_root_nodes){
- log_it(L_ATT,"Not found bootstrap addresses, fill seed nodelist from root aliases");
+ } else {
+ log_it(L_ATT, "Not use bootstrap addresses, fill seed nodelist from root aliases");
pthread_rwlock_unlock(&l_net_pvt->rwlock);
s_fill_links_from_root_aliases(l_net);
pthread_rwlock_wrlock(&l_net_pvt->rwlock);
@@ -989,12 +1142,13 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
case NET_STATE_LINKS_CONNECTING: {
log_it(L_INFO, "%s.state: NET_STATE_LINKS_CONNECTING",l_net->pub.name);
- for (dap_list_t *l_tmp = l_net_pvt->links_info; l_tmp; l_tmp = dap_list_next(l_tmp)) {
- dap_chain_node_info_t *l_link_info = (dap_chain_node_info_t *)l_tmp->data;
+ int l_used_links = 0;
+ for (dap_list_t *l_tmp = l_net_pvt->net_links; l_tmp; l_tmp = dap_list_next(l_tmp)) {
+ dap_chain_node_info_t *l_link_info = ((struct net_link *)l_tmp->data)->link_info;
dap_chain_node_client_t *l_client = dap_chain_net_client_create_n_connect(l_net, l_link_info);
l_client->keep_connection = true;
- l_net_pvt->links = dap_list_append(l_net_pvt->links, l_client);
- if (dap_list_length(l_net_pvt->links) == s_required_links_count)
+ ((struct net_link *)l_tmp->data)->link = l_client;
+ if (++l_used_links == s_required_links_count)
break;
}
} break;
@@ -1030,15 +1184,14 @@ bool dap_chain_net_sync_trylock(dap_chain_net_t *a_net, dap_chain_node_client_t
pthread_rwlock_rdlock(&l_net_pvt->rwlock);
bool l_found = false;
if (l_net_pvt->active_link) {
- for (dap_list_t *l_links = l_net_pvt->links; l_links; l_links = dap_list_next(l_links)) {
- if (l_links->data == l_net_pvt->active_link) {
- dap_chain_node_client_t *l_client = (dap_chain_node_client_t *)l_links->data;
- if (l_client->state >= NODE_CLIENT_STATE_ESTABLISHED &&
+ for (dap_list_t *l_links = l_net_pvt->net_links; l_links; l_links = dap_list_next(l_links)) {
+ dap_chain_node_client_t *l_client = ((struct net_link *)l_links->data)->link;
+ if (l_client == l_net_pvt->active_link &&
+ l_client->state >= NODE_CLIENT_STATE_ESTABLISHED &&
l_client->state < NODE_CLIENT_STATE_SYNCED &&
a_client != l_client) {
- l_found = true;
- break;
- }
+ l_found = true;
+ break;
}
}
}
@@ -1236,7 +1389,7 @@ void s_set_reply_text_node_status(char **a_str_reply, dap_chain_net_t * a_net){
if (PVT(a_net)->state != NET_STATE_OFFLINE)
l_sync_current_link_text_block = dap_strdup_printf(", active links %u from %u",
PVT(a_net)->links_connected_count,
- dap_list_length(PVT(a_net)->links));
+ dap_list_length(PVT(a_net)->net_links));
dap_chain_node_cli_set_reply_text(a_str_reply,
"Network \"%s\" has state %s (target state %s)%s%s",
a_net->pub.name, c_net_states[PVT(a_net)->state],
@@ -1440,11 +1593,11 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
size_t i =0;
dap_chain_net_pvt_t * l_net_pvt = PVT(l_net);
pthread_rwlock_rdlock(&l_net_pvt->rwlock );
- size_t l_links_count = dap_list_length(l_net_pvt->links);
+ size_t l_links_count = dap_list_length(l_net_pvt->net_links);
dap_string_t *l_reply = dap_string_new("");
dap_string_append_printf(l_reply,"Links %zu:\n", l_links_count);
- for (dap_list_t * l_item = l_net_pvt->links; l_item; l_item = l_item->next ) {
- dap_chain_node_client_t * l_node_client = l_item->data;
+ for (dap_list_t * l_item = l_net_pvt->net_links; l_item; l_item = l_item->next ) {
+ dap_chain_node_client_t *l_node_client = ((struct net_link *)l_item->data)->link;
if(l_node_client){
dap_chain_node_info_t * l_info = l_node_client->info;
@@ -2550,7 +2703,7 @@ void dap_chain_net_proc_mempool (dap_chain_net_t * a_net)
dap_chain_datum_tx_t * dap_chain_net_get_tx_by_hash(dap_chain_net_t * a_net, dap_chain_hash_fast_t * a_tx_hash,
dap_chain_net_tx_search_type_t a_search_type)
{
- dap_ledger_t * l_ledger = dap_chain_ledger_by_net_name( a_net->pub.name );
+ dap_ledger_t * l_ledger = a_net->pub.ledger;
dap_chain_datum_tx_t * l_tx = NULL;
switch (a_search_type) {
@@ -2562,7 +2715,7 @@ dap_chain_datum_tx_t * dap_chain_net_get_tx_by_hash(dap_chain_net_t * a_net, dap
for ( dap_chain_t * l_chain = a_net->pub.chains; l_chain; l_chain = l_chain->next){
if ( l_chain->callback_tx_find_by_hash ){
// try to find transaction in chain ( inside shard )
- l_tx = l_chain->callback_tx_find_by_hash( l_chain, a_tx_hash );
+ l_tx = l_chain->callback_tx_find_by_hash(l_chain, a_tx_hash);
if (l_tx)
break;
}
@@ -2572,7 +2725,7 @@ dap_chain_datum_tx_t * dap_chain_net_get_tx_by_hash(dap_chain_net_t * a_net, dap
case TX_SEARCH_TYPE_NET_UNSPENT:
case TX_SEARCH_TYPE_CELL_UNSPENT:{
- l_tx = dap_chain_ledger_tx_find_by_hash( l_ledger, a_tx_hash );
+ l_tx = dap_chain_ledger_tx_find_by_hash(l_ledger, a_tx_hash);
}break;
}
return l_tx;
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index d2810653a9b10cd519004dce83f6cc68d49e4b42..cb44195f73a31bb3ba3e52728b6555d8fc20f316 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -90,38 +90,24 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
dap_ledger_t *a_ledger,
dap_string_t *a_str_out,
const char *a_hash_out_type,
- bool save_processed_tx,
- dap_chain_tx_hash_processed_ht_t **a_tx_hash_processed,
- size_t *l_tx_num)
+ dap_chain_hash_fast_t *a_tx_hash)
{
- dap_chain_hash_fast_t l_tx_hash;
- dap_hash_fast(a_datum, dap_chain_datum_tx_get_size(a_datum), &l_tx_hash);
- if (save_processed_tx){
- dap_chain_tx_hash_processed_ht_t *l_sht = NULL;
- HASH_FIND(hh, *a_tx_hash_processed, &l_tx_hash, sizeof(dap_chain_hash_fast_t), l_sht);
- if (l_sht != NULL)
- return;
- l_sht = DAP_NEW_Z(dap_chain_tx_hash_processed_ht_t);
- memcpy(&l_sht->hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t));
- HASH_ADD(hh, *a_tx_hash_processed, hash, sizeof(dap_chain_hash_fast_t), l_sht);
- (*l_tx_num)++;
- }
time_t l_ts_create = (time_t)a_datum->header.ts_created;
char *l_hash_str = NULL;
if (!dap_strcmp(a_hash_out_type, "hex"))
- l_hash_str = dap_chain_hash_fast_to_str_new(&l_tx_hash);
+ l_hash_str = dap_chain_hash_fast_to_str_new(a_tx_hash);
else
- l_hash_str = dap_enc_base58_encode_hash_to_str(&l_tx_hash);
+ l_hash_str = dap_enc_base58_encode_hash_to_str(a_tx_hash);
dap_list_t *l_list_tx_any = dap_chain_datum_tx_items_get(a_datum, TX_ITEM_TYPE_TOKEN, NULL);
if(a_ledger == NULL){
- dap_string_append_printf(a_str_out, "transaction: %s hash: %s\n Items:\n", l_list_tx_any ? "(emit)" : "", l_hash_str);
+ dap_string_append_printf(a_str_out, "transaction:%s hash: %s\n Items:\n", l_list_tx_any ? "(emit)" : "", l_hash_str);
} else {
char buf[50];
const char *l_ticker;
if (l_list_tx_any) {
l_ticker = ((dap_chain_tx_token_t*)l_list_tx_any->data)->header.ticker;
} else {
- l_ticker = dap_chain_ledger_tx_get_token_ticker_by_hash(a_ledger, &l_tx_hash);
+ l_ticker = dap_chain_ledger_tx_get_token_ticker_by_hash(a_ledger, a_tx_hash);
}
dap_string_append_printf(a_str_out, "transaction:%s hash: %s\n TS Created: %s Token ticker: %s\n Items:\n",
l_list_tx_any ? " (emit)" : "", l_hash_str, dap_ctime_r(&l_ts_create, buf), l_ticker);
@@ -897,183 +883,192 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
size_t l_datum_num = 0, l_token_num = 0, l_emission_num = 0, l_tx_num = 0;
size_t l_datum_num_global = a_total_datums ? *a_total_datums : 0;
while(l_atom && l_atom_size) {
- size_t l_datums_count = 0;
- dap_chain_datum_t **l_datums =
- (a_chain->callback_atom_get_datums && l_atom && l_atom_size) ?
- a_chain->callback_atom_get_datums(l_atom, l_atom_size, &l_datums_count) : NULL;
- if(!l_datums) {
- log_it(L_WARNING, "Not defined callback_atom_get_datums for chain \"%s\"", a_chain->name);
- return NULL ;
- }
- for(size_t l_datum_n = 0; l_datum_n < l_datums_count; l_datum_n++) {
-
- dap_chain_datum_t *l_datum = l_datums[l_datum_n];
- if(!l_datum) { // || l_datum->header.type_id != DAP_CHAIN_DATUM_TX) {
- // go to next atom
- //l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
- continue;
+ size_t l_datums_count = 0;
+ dap_chain_datum_t **l_datums =
+ (a_chain->callback_atom_get_datums && l_atom && l_atom_size) ?
+ a_chain->callback_atom_get_datums(l_atom, l_atom_size, &l_datums_count) : NULL;
+ if(!l_datums) {
+ log_it(L_WARNING, "Not defined callback_atom_get_datums for chain \"%s\"", a_chain->name);
+ return NULL ;
}
+ for(size_t l_datum_n = 0; l_datum_n < l_datums_count; l_datum_n++) {
- /*dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain);
- dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter);
- size_t l_atom_size = a_chain->callback_atom_get_size(l_atom);
- size_t l_datum_num = 0, l_token_num = 0, l_emission_num = 0, l_tx_num = 0;
- while(l_atom && l_atom_size) {
- dap_chain_datum_t *l_datum =
- a_chain->callback_atom_get_datum ?
- a_chain->callback_atom_get_datum(l_atom) : (dap_chain_datum_t*) l_atom;
- if(!l_datum) {
- // go to next transaction
- l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter);
- l_atom_size = a_chain->callback_atom_get_size(l_atom);
- log_it(L_ERROR, "datum=NULL for atom=0x%x", l_atom);
- continue;
- }*/
- char l_time_str[70];
- // get time of create datum
- if(dap_time_to_str_rfc822(l_time_str, 71, l_datum->header.ts_create) < 1)
- l_time_str[0] = '\0';
- switch (l_datum->header.type_id) {
-
- // token
- case DAP_CHAIN_DATUM_TOKEN_DECL: {
-
- // no token necessary for addr
- if(a_filtr_addr_base58) {
- break;
+ dap_chain_datum_t *l_datum = l_datums[l_datum_n];
+ if(!l_datum) { // || l_datum->header.type_id != DAP_CHAIN_DATUM_TX) {
+ // go to next atom
+ //l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
+ continue;
}
- dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
- //if(a_datum_start < 0 || (l_datum_num >= a_datum_start && l_datum_num < a_datum_end))
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)){
- l_token_num++;
- break;
- }
- if(!a_filter_token_name || !dap_strcmp(l_token->ticker, a_filter_token_name)) {
- dap_string_append_printf(l_str_out, "token %s, created: %s\n", l_token->ticker, l_time_str);
- switch (l_token->type) {
- // Simple private token decl
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:
- dap_string_append_printf(l_str_out, " total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
- l_token->header_private.total_supply / DATOSHI_LD,
- l_token->header_private.total_supply,
- l_token->header_private.signs_valid, l_token->header_private.signs_total);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
- dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
- l_token->header_private_decl.tsd_total_size,
- l_token->header_private_decl.flags);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
- dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
- l_token->header_private_update.tsd_total_size,
- l_token->header_private_update.padding);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: {
- char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
- char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
- dap_string_append_printf(l_str_out,
- " total_supply: %s(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
- //l_token->header_public.total_supply / DATOSHI_LD,
- dap_chain_balance_to_coins(l_token->header_public.total_supply),
- dap_chain_balance_print(l_token->header_public.total_supply),
- l_token->header_public.flags,
- dap_chain_balance_print(l_token->header_public.premine_supply),
- l_addr ? l_addr : "-");
- DAP_DELETE(l_addr);
- DAP_DELETE(l_balance);
+ /*dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain);
+ dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter);
+ size_t l_atom_size = a_chain->callback_atom_get_size(l_atom);
+ size_t l_datum_num = 0, l_token_num = 0, l_emission_num = 0, l_tx_num = 0;
+ while(l_atom && l_atom_size) {
+ dap_chain_datum_t *l_datum =
+ a_chain->callback_atom_get_datum ?
+ a_chain->callback_atom_get_datum(l_atom) : (dap_chain_datum_t*) l_atom;
+ if(!l_datum) {
+ // go to next transaction
+ l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter);
+ l_atom_size = a_chain->callback_atom_get_size(l_atom);
+ log_it(L_ERROR, "datum=NULL for atom=0x%x", l_atom);
+ continue;
+ }*/
+ char l_time_str[70];
+ // get time of create datum
+ if(dap_time_to_str_rfc822(l_time_str, 71, l_datum->header.ts_create) < 1)
+ l_time_str[0] = '\0';
+ switch (l_datum->header.type_id) {
+
+ // token
+ case DAP_CHAIN_DATUM_TOKEN_DECL: {
+
+ // no token necessary for addr
+ if(a_filtr_addr_base58) {
+ break;
}
+
+ dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
+ //if(a_datum_start < 0 || (l_datum_num >= a_datum_start && l_datum_num < a_datum_end))
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)){
+ l_token_num++;
break;
- default:
- dap_string_append_printf(l_str_out, "unknown token type: 0x%x\n", l_token->type);
- break;
+ }
+ if(!a_filter_token_name || !dap_strcmp(l_token->ticker, a_filter_token_name)) {
+ dap_string_append_printf(l_str_out, "token %s, created: %s\n", l_token->ticker, l_time_str);
+ switch (l_token->type) {
+ // Simple private token decl
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:
+ dap_string_append_printf(l_str_out, " total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
+ l_token->header_private.total_supply / DATOSHI_LD,
+ l_token->header_private.total_supply,
+ l_token->header_private.signs_valid, l_token->header_private.signs_total);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+ l_token->header_private_decl.tsd_total_size,
+ l_token->header_private_decl.flags);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
+ l_token->header_private_update.tsd_total_size,
+ l_token->header_private_update.padding);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: {
+ char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
+ char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
+ dap_string_append_printf(l_str_out,
+ " total_supply: %s(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
+ //l_token->header_public.total_supply / DATOSHI_LD,
+ dap_chain_balance_to_coins(l_token->header_public.total_supply),
+ dap_chain_balance_print(l_token->header_public.total_supply),
+ l_token->header_public.flags,
+ dap_chain_balance_print(l_token->header_public.premine_supply),
+ l_addr ? l_addr : "-");
+ DAP_DELETE(l_addr);
+ DAP_DELETE(l_balance);
+ }
+ break;
+ default:
+ dap_string_append_printf(l_str_out, "unknown token type: 0x%x\n", l_token->type);
+ break;
+ }
+ dap_string_append_printf(l_str_out, "\n");
+ l_token_num++;
}
- dap_string_append_printf(l_str_out, "\n");
- l_token_num++;
}
- }
- break;
+ break;
- // emission
- case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
- l_token_num++;
- break;
- }
- size_t l_emission_size = dap_chain_datum_emission_get_size(l_datum->data);
- dap_chain_datum_token_emission_t *l_token_em = dap_chain_datum_emission_read(l_datum->data, &l_emission_size);
- if(!a_filter_token_name || !dap_strcmp(l_token_em->hdr.ticker, a_filter_token_name)) {
- char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_em->hdr.address));
- // filter for addr
- if (a_filtr_addr_base58 && dap_strcmp(a_filtr_addr_base58,l_token_emission_address_str)) {
+ // emission
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
+ l_token_num++;
break;
}
+ size_t l_emission_size = dap_chain_datum_emission_get_size(l_datum->data);
+ dap_chain_datum_token_emission_t *l_token_em = dap_chain_datum_emission_read(l_datum->data, &l_emission_size);
+ if(!a_filter_token_name || !dap_strcmp(l_token_em->hdr.ticker, a_filter_token_name)) {
+ char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_em->hdr.address));
+ // filter for addr
+ if (a_filtr_addr_base58 && dap_strcmp(a_filtr_addr_base58,l_token_emission_address_str)) {
+ break;
+ }
- dap_string_append_printf(l_str_out, "emission: %.0Lf(%"DAP_UINT64_FORMAT_U") %s, type: %s, version: %d\n",
- l_token_em->hdr.value / DATOSHI_LD, l_token_em->hdr.value, l_token_em->hdr.ticker,
- c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
- l_token_em->hdr.version);
- dap_string_append_printf(l_str_out, " to addr: %s\n", l_token_emission_address_str);
+ dap_string_append_printf(l_str_out, "emission: %.0Lf(%"DAP_UINT64_FORMAT_U") %s, type: %s, version: %d\n",
+ l_token_em->hdr.value / DATOSHI_LD, l_token_em->hdr.value, l_token_em->hdr.ticker,
+ c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
+ l_token_em->hdr.version);
+ dap_string_append_printf(l_str_out, " to addr: %s\n", l_token_emission_address_str);
+
+ DAP_DELETE(l_token_emission_address_str);
+ switch (l_token_em->hdr.type) {
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:
+ dap_string_append_printf(l_str_out, " signs_count: %d\n", l_token_em->data.type_auth.signs_count);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
+ dap_string_append_printf(l_str_out, " codename: %s\n", l_token_em->data.type_algo.codename);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
+ dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
+ l_token_em->data.type_atom_owner.value_start / DATOSHI_LD,
+ l_token_em->data.type_atom_owner.value_start,
+ l_token_em->data.type_atom_owner.value_change_algo_codename);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT: {
+ char *l_addr = dap_chain_addr_to_str(&l_token_em->data.type_presale.addr);
+ // get time of create datum
+ if(dap_time_to_str_rfc822(l_time_str, 71, l_token_em->data.type_presale.lock_time) < 1)
+ l_time_str[0] = '\0';
+ dap_string_append_printf(l_str_out, " flags: 0x%x, lock_time: %s\n", l_token_em->data.type_presale.flags, l_time_str);
+ dap_string_append_printf(l_str_out, " addr: %s\n", l_addr);
+ DAP_DELETE(l_addr);
+ }
+ break;
+ }
+ dap_string_append_printf(l_str_out, "\n");
+ l_emission_num++;
+ }
+ DAP_DELETE(l_token_em);
+ } break;
- DAP_DELETE(l_token_emission_address_str);
- switch (l_token_em->hdr.type) {
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:
- dap_string_append_printf(l_str_out, " signs_count: %d\n", l_token_em->data.type_auth.signs_count);
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
- dap_string_append_printf(l_str_out, " codename: %s\n", l_token_em->data.type_algo.codename);
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
- dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
- l_token_em->data.type_atom_owner.value_start / DATOSHI_LD,
- l_token_em->data.type_atom_owner.value_start,
- l_token_em->data.type_atom_owner.value_change_algo_codename);
+ // transaction
+ case DAP_CHAIN_DATUM_TX:{
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
+ l_tx_num++;
break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT: {
- char *l_addr = dap_chain_addr_to_str(&l_token_em->data.type_presale.addr);
- // get time of create datum
- if(dap_time_to_str_rfc822(l_time_str, 71, l_token_em->data.type_presale.lock_time) < 1)
- l_time_str[0] = '\0';
- dap_string_append_printf(l_str_out, " flags: 0x%x, lock_time: %s\n", l_token_em->data.type_presale.flags, l_time_str);
- dap_string_append_printf(l_str_out, " addr: %s\n", l_addr);
- DAP_DELETE(l_addr);
}
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
+ //calc tx hash
+ dap_chain_hash_fast_t l_tx_hash;
+ dap_hash_fast(l_tx, dap_chain_datum_tx_get_size(l_tx), &l_tx_hash);
+ dap_chain_tx_hash_processed_ht_t *l_sht = NULL;
+ HASH_FIND(hh, a_tx_hash_processed, &l_tx_hash, sizeof(dap_chain_hash_fast_t), l_sht);
+ if (l_sht != NULL)
break;
- }
- dap_string_append_printf(l_str_out, "\n");
- l_emission_num++;
- }
- DAP_DELETE(l_token_em);
- } break;
-
- // transaction
- case DAP_CHAIN_DATUM_TX:{
-
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
+ l_sht = DAP_NEW_Z(dap_chain_tx_hash_processed_ht_t);
+ memcpy(&l_sht->hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t));
+ HASH_ADD(hh, a_tx_hash_processed, hash, sizeof(dap_chain_hash_fast_t), l_sht);
l_tx_num++;
+ s_dap_chain_datum_tx_out_data(l_tx, a_ledger, l_str_out, a_hash_out_type, &l_tx_hash);
+ }
+ break;
+ default:
+ dap_string_append_printf(l_str_out, "unknown datum type=%d\n", l_datum->header.type_id);
break;
}
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
- //calc tx hash
- s_dap_chain_datum_tx_out_data(l_tx, a_ledger, l_str_out, a_hash_out_type, true, &a_tx_hash_processed, &l_tx_num);
- }
- break;
- default:
- dap_string_append_printf(l_str_out, "unknown datum type=%d\n", l_datum->header.type_id);
- break;
+ l_datum_num++;
}
- l_datum_num++;
- }
- // go to next transaction
- l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
- //l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter);
- //l_atom_size = a_chain->callback_atom_get_size(l_atom);
+ // go to next transaction
+ l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
+ //l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter);
+ //l_atom_size = a_chain->callback_atom_get_size(l_atom);
}
a_chain->callback_atom_iter_delete(l_atom_iter);
//total
@@ -1185,7 +1180,8 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_hash_fast_t l_tx_hash;
if(l_tx_hash_str) {
- if(dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash) < 0) {
+ if (dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash) &&
+ dap_enc_base58_hex_to_hash(l_tx_hash_str, &l_tx_hash)) {
l_tx_hash_str = NULL;
dap_chain_node_cli_set_reply_text(a_str_reply, "tx hash not recognized");
return -1;
@@ -1281,9 +1277,13 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
int l_sub_cmd = SUBCMD_NONE;
if (dap_chain_node_cli_find_option_val(a_argv, 2, 3, "coins", NULL ))
l_sub_cmd = SUBCMD_LIST_COIN;
+ if (l_sub_cmd == SUBCMD_NONE) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'list' requires parmeter -coins");
+ return -5;
+ }
dap_chain_node_cli_find_option_val(a_argv, 3, a_argc, "-net", &l_net_str);
if (l_net_str == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command requires key -net");
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'list' requires key -net");
return -1;
}
dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name(l_net_str);
@@ -1306,38 +1306,43 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-hash", &l_tx_hash_str);
//get net
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
+ //get search type
+ const char *l_unspent_str = NULL;
+ dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-unspent", &l_unspent_str);
//check input
if (l_tx_hash_str == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires key -hash");
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand 'info' requires key -hash");
return -1;
}
if (l_net_str == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires key -net");
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand 'info' requires key -net");
return -1;
}
- dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name(l_net_str);
- if (l_ledger == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't get ledger for net %s", l_net_str);
+ dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
+ if (!l_net) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find net %s", l_net_str);
return -2;
}
+
dap_chain_hash_fast_t *l_tx_hash = DAP_NEW(dap_chain_hash_fast_t);
if (dap_chain_hash_fast_from_str(l_tx_hash_str, l_tx_hash) &&
dap_enc_base58_hex_to_hash(l_tx_hash_str, l_tx_hash)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Can't get hash_fast from %s", l_tx_hash_str);
return -2;
}
- dap_chain_datum_tx_t *l_datum_tx = dap_chain_ledger_tx_find_by_hash(l_ledger, l_tx_hash);
+ dap_chain_datum_tx_t *l_datum_tx = dap_chain_net_get_tx_by_hash(l_net, l_tx_hash,
+ l_unspent_str ? TX_SEARCH_TYPE_NET_UNSPENT : TX_SEARCH_TYPE_NET);
if (l_datum_tx == NULL){
dap_chain_node_cli_set_reply_text(a_str_reply, "Can't get datum from transaction hash %s", l_tx_hash_str);
return -2;
}
dap_string_t *l_str = dap_string_new("");
- s_dap_chain_datum_tx_out_data(l_datum_tx, l_ledger, l_str, l_hash_out_type, false, NULL, NULL);
+ s_dap_chain_datum_tx_out_data(l_datum_tx, l_net->pub.ledger, l_str, l_hash_out_type, l_tx_hash);
dap_chain_node_cli_set_reply_text(a_str_reply, l_str->str);
dap_string_free(l_str, true);
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter 'list' or 'tx' or 'info'");
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'ledger' requires parameter 'list' or 'tx' or 'info'");
return -1;
}
return 0;
diff --git a/modules/net/dap_chain_node_dns_client.c b/modules/net/dap_chain_node_dns_client.c
index af3c5a5684acea9c28e4fb477d6447249d503f57..419841a1c9e00d0c5f51f1f13b19828c64c2aa1f 100644
--- a/modules/net/dap_chain_node_dns_client.c
+++ b/modules/net/dap_chain_node_dns_client.c
@@ -219,6 +219,7 @@ int dap_chain_node_info_dns_request(struct in_addr a_addr, uint16_t a_port, char
}
l_dns_client->dns_request = DAP_NEW_Z(dap_dns_buf_t);
if( ! l_dns_client->dns_request){
+ DAP_DELETE(l_dns_client->buf);
DAP_DELETE(l_dns_client);
return -3;
}
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 42799d60a6dbd6304160e35ffe865fadbe71777d..dca78a4dda1344b474b223e0a7bc57bc2d297cd7 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -55,7 +55,7 @@
typedef struct dap_chain_cs_dag_event_item {
dap_chain_hash_fast_t hash;
- dap_chain_hash_fast_t hash_event_content;
+ const char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
time_t ts_added;
dap_chain_cs_dag_event_t *event;
size_t event_size;
@@ -96,8 +96,8 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
static dap_chain_atom_ptr_t s_chain_callback_atom_iter_find_by_hash(dap_chain_atom_iter_t * a_atom_iter ,
dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size);
-static dap_chain_datum_tx_t* s_chain_callback_atom_iter_find_by_tx_hash(dap_chain_t * a_chain ,
- dap_chain_hash_fast_t * a_atom_hash);
+static dap_chain_datum_tx_t* s_chain_callback_atom_find_by_tx_hash(dap_chain_t *a_chain,
+ dap_chain_hash_fast_t *a_tx_hash);
static dap_chain_datum_t** s_chain_callback_atom_get_datum(dap_chain_atom_ptr_t a_event, size_t a_atom_size, size_t *a_datums_count);
// Get event(s) from dag
@@ -214,7 +214,7 @@ int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
a_chain->callback_atom_iter_get_lasts = s_chain_callback_atom_iter_get_lasts;
a_chain->callback_atom_find_by_hash = s_chain_callback_atom_iter_find_by_hash;
- a_chain->callback_tx_find_by_hash = s_chain_callback_atom_iter_find_by_tx_hash;
+ a_chain->callback_tx_find_by_hash = s_chain_callback_atom_find_by_tx_hash;
a_chain->callback_add_datums = s_chain_callback_datums_pool_proc;
@@ -357,9 +357,9 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
l_tx_event->ts_added = a_event_item->ts_added;
l_tx_event->event = a_event_item->event;
l_tx_event->event_size = a_event_item->event_size;
- memcpy(&l_tx_event->hash, &a_event_item->hash, sizeof (l_tx_event->hash) );
+ dap_hash_fast(l_tx, dap_chain_datum_tx_get_size(l_tx), &l_tx_event->hash);
int l_err = pthread_rwlock_wrlock(l_events_rwlock);
- HASH_ADD(hh,PVT(a_dag)->tx_events, hash, sizeof (l_tx_event->hash), l_tx_event);
+ HASH_ADD(hh, PVT(a_dag)->tx_events, hash, sizeof(l_tx_event->hash), l_tx_event);
if (l_err != EDEADLK) {
pthread_rwlock_unlock(l_events_rwlock);
}
@@ -1212,16 +1212,16 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_find_by_hash(dap_chain_at
}
-static dap_chain_datum_tx_t* s_chain_callback_atom_iter_find_by_tx_hash(dap_chain_t * a_chain ,
- dap_chain_hash_fast_t * a_atom_hash)
+static dap_chain_datum_tx_t* s_chain_callback_atom_find_by_tx_hash(dap_chain_t *a_chain,
+ dap_chain_hash_fast_t *a_tx_hash)
{
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG( a_chain );
dap_chain_cs_dag_event_item_t * l_event_item = NULL;
pthread_rwlock_rdlock(&PVT(l_dag)->events_rwlock);
- HASH_FIND(hh, PVT(l_dag)->tx_events,a_atom_hash,sizeof(*a_atom_hash),l_event_item);
+ HASH_FIND(hh, PVT(l_dag)->tx_events, a_tx_hash, sizeof(*a_tx_hash), l_event_item);
pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
if ( l_event_item ){
- dap_chain_datum_t * l_datum = dap_chain_cs_dag_event_get_datum(l_event_item->event, l_event_item->event_size) ;
+ dap_chain_datum_t *l_datum = dap_chain_cs_dag_event_get_datum(l_event_item->event, l_event_item->event_size);
return l_datum ? l_datum->header.data_size ? (dap_chain_datum_tx_t*) l_datum->data : NULL :NULL;
}else
return NULL;