diff --git a/3rdparty/cuttdb/CMakeLists.txt b/3rdparty/cuttdb/CMakeLists.txt
index 8cf9f34ac98198a42100658743882ac0b31a3bba..fcb7e8a592494e323eaec17a0a46cd909ad38b05 100755
--- a/3rdparty/cuttdb/CMakeLists.txt
+++ b/3rdparty/cuttdb/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.10)
project(dap_cuttdb C)
diff --git a/3rdparty/json-c-darwin/CMakeLists.txt b/3rdparty/json-c-darwin/CMakeLists.txt
index 455c70f283a430a482d5350b6a8e9e0fceddecdf..f051a06cdd03295a8e14a30aa5484bb8c9d50b13 100644
--- a/3rdparty/json-c-darwin/CMakeLists.txt
+++ b/3rdparty/json-c-darwin/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (json-c)
file(GLOB JSON_C_SRCS FILES *.c)
diff --git a/3rdparty/json-c/CMakeLists.txt b/3rdparty/json-c/CMakeLists.txt
index 455c70f283a430a482d5350b6a8e9e0fceddecdf..f051a06cdd03295a8e14a30aa5484bb8c9d50b13 100644
--- a/3rdparty/json-c/CMakeLists.txt
+++ b/3rdparty/json-c/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (json-c)
file(GLOB JSON_C_SRCS FILES *.c)
diff --git a/3rdparty/libmagic-darwin/CMakeLists.txt b/3rdparty/libmagic-darwin/CMakeLists.txt
index 5c44277f082502ac2c2f08017884c4b71ea95e5a..c7356c623c0be98aeb1f2da5f820d238d1101852 100755
--- a/3rdparty/libmagic-darwin/CMakeLists.txt
+++ b/3rdparty/libmagic-darwin/CMakeLists.txt
@@ -3,7 +3,7 @@
# value of 3.4.0 or lower.
# by huzongyao
-cmake_minimum_required(VERSION 3.4.1)
+cmake_minimum_required(VERSION 3.10)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -DHAVE_CONFIG_H -I/usr/lib/jvm/java-8-openjdk-amd64/include/ -I/usr/lib/jvm/java-8-openjdk-amd64/include/linux/")
diff --git a/3rdparty/libmagic/CMakeLists.txt b/3rdparty/libmagic/CMakeLists.txt
index 33a21014bb650e31989703556be2df618bd20fd0..681005e1e0469216d454ce219db5ee09d101a4a8 100755
--- a/3rdparty/libmagic/CMakeLists.txt
+++ b/3rdparty/libmagic/CMakeLists.txt
@@ -3,7 +3,7 @@
# value of 3.4.0 or lower.
# by huzongyao
-cmake_minimum_required(VERSION 3.4.1)
+cmake_minimum_required(VERSION 3.10)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -DHAVE_CONFIG_H -I/usr/lib/jvm/java-8-openjdk-amd64/include/ -I/usr/lib/jvm/java-8-openjdk-amd64/include/linux/")
diff --git a/3rdparty/wolfssl/CMakeLists.txt b/3rdparty/wolfssl/CMakeLists.txt
index 171c8ef3fadf66c1b988be8af14d59b14f9767bb..c6a14fd2e6825b533b50e5e8fcd3cde8dbe7a058 100644
--- a/3rdparty/wolfssl/CMakeLists.txt
+++ b/3rdparty/wolfssl/CMakeLists.txt
@@ -19,7 +19,7 @@
# Project
####################################################
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.10)
if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
message(FATAL_ERROR "In-source builds are not allowed.\
diff --git a/CMakeLists.txt b/CMakeLists.txt
index efe32c7df4701740435185f10fabd5b06eb7bfab..4fcc818e8421210505a1f140ebb39bf3e172957d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,9 +1,28 @@
project(cellframe-sdk C)
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
set(CMAKE_C_STANDARD 11)
set(CELLFRAME_SDK_NATIVE_VERSION "3.1-0")
+
add_definitions ("-DCELLFRAME_SDK_VERSION=\"${CELLFRAME_SDK_NATIVE_VERSION}\"")
+
+set(BUILD_CRYPTO_TESTS ON)
+
+if(NOT DEFINED ${CELLFRAME_MODULES})
+ include (cmake/OS_Detection.cmake)
+ if (WIN32)
+ set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-none srv-app srv-app-db srv-datum srv-stake srv-xchange")
+ elseif(BSD)
+ set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-none srv-app srv-app-db srv-datum srv-stake srv-xchange")
+ elseif(DARWIN)
+ set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-none srv-app srv-app-db srv-datum srv-stake srv-xchange")
+ elseif(ANDROID)
+ set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-none srv-app srv-app-db srv-datum srv-stake srv-xchange")
+ elseif(LINUX)
+ set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-none srv-app srv-app-db srv-datum srv-stake srv-xchange modules-dynamic srv-vpn")
+ endif()
+endif()
+
set(DAPSDK_MODULES "")
if(NOT DEFINED ${CELLFRAME_MODULES})
diff --git a/cmake/OS_Detection.cmake b/cmake/OS_Detection.cmake
index a4d15a653c13b2ca287431446ce10a78a93c5679..8148074e3a757572b7abc583b6e128ead19cec98 100644
--- a/cmake/OS_Detection.cmake
+++ b/cmake/OS_Detection.cmake
@@ -1,3 +1,5 @@
+include_guard(GLOBAL)
+
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
set(OS_TYPE_DESKTOP ON)
set(LINUX ON)
diff --git a/dap-sdk/CMakeLists.txt b/dap-sdk/CMakeLists.txt
index f1b30e0ed0b169065f03f9b01d38c9ae34a4d3c9..9a6f3fa6394bd90cbc3d3d93c2aae300b843a209 100644
--- a/dap-sdk/CMakeLists.txt
+++ b/dap-sdk/CMakeLists.txt
@@ -1,4 +1,4 @@
-set(DAP_SDK_NATIVE_VERSION "2.3-0")
+set(DAP_SDK_NATIVE_VERSION "2.2-2")
# We switch off SSL until its not switched on back
if(DAPSDK_MODULES MATCHES "ssl-support")
diff --git a/dap-sdk/core/CMakeLists.txt b/dap-sdk/core/CMakeLists.txt
index 60cb7dc92bb74181db1175cbff2a015ee55576f3..5956ea55318d1c3e02efe8d27c8ecb2d06c21a83 100755
--- a/dap-sdk/core/CMakeLists.txt
+++ b/dap-sdk/core/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_core)
add_definitions("-D_GNU_SOURCE")
diff --git a/dap-sdk/core/include/dap_common.h b/dap-sdk/core/include/dap_common.h
index a5460b55f1b16422a19924985ac53fcf5b34aa2d..7e4f3c69e8db6be34eaba0e9d66c1824d6d377f6 100755
--- a/dap-sdk/core/include/dap_common.h
+++ b/dap-sdk/core/include/dap_common.h
@@ -143,7 +143,7 @@ typedef uint8_t byte_t;
#define DAP_DUP_SIZE(a, s) memcpy(malloc(s), a, s)
#endif
-#define DAP_DEL_Z(a) if(a) { DAP_DELETE(a); a=NULL;}
+#define DAP_DEL_Z(a) if (a) { DAP_DELETE(a); (a) = NULL; }
DAP_STATIC_INLINE void *_dap_aligned_alloc( uintptr_t alignment, uintptr_t size )
{
@@ -451,6 +451,7 @@ char *dap_log_get_item(time_t a_start_time, int a_limit);
#define DAP_PRINTF_ATTR(format_index, args_index)
#endif /* __GNUC__ */
+
DAP_PRINTF_ATTR(3, 4) void _log_it( const char * log_tag, enum dap_log_level, const char * format, ... );
#define log_it( _log_level, ...) _log_it( LOG_TAG, _log_level, ##__VA_ARGS__)
diff --git a/dap-sdk/core/include/dap_math_ops.h b/dap-sdk/core/include/dap_math_ops.h
index 5cc8142dd9757d042dc4b9b9403d092c02bf7a58..c030d1007552881075d3d8883b5183870e7d7b41 100755
--- a/dap-sdk/core/include/dap_math_ops.h
+++ b/dap-sdk/core/include/dap_math_ops.h
@@ -1,5 +1,4 @@
#pragma once
-
#include <stdint.h>
#include <stdio.h>
#include "assert.h"
@@ -14,22 +13,17 @@
#if __SIZEOF_INT128__ == 16
#define DAP_GLOBAL_IS_INT128
-
-#endif
-
-
-#ifdef DAP_GLOBAL_IS_INT128
typedef __int128 _dap_int128_t;
-//#if !defined (int128_t)
+#if !defined (int128_t)
typedef __int128 int128_t;
-//#endif
+#endif
-//#if !defined (uint128_t)
+#if !defined (uint128_t)
typedef unsigned __int128 uint128_t;
-//#endif
+#endif
-#else //DAP_GLOBAL_IS_INT128
+#else // __SIZEOF_INT128__ == 16
typedef union uint128 {
struct{
@@ -50,16 +44,16 @@ typedef union int128 {
int32_t i32[4];
} int128_t;
-#endif //DAP_GLOBAL_IS_INT128
-
typedef int128_t _dap_int128_t;
-typedef struct uint256 {
+#endif // __SIZEOF_INT128__ == 16
+
+typedef struct uint256_t {
uint128_t hi;
uint128_t lo;
} DAP_ALIGN_PACKED uint256_t;
-typedef struct uint512 {
+typedef struct uint512_t {
uint256_t hi;
uint256_t lo;
} DAP_ALIGN_PACKED uint512_t;
@@ -69,33 +63,14 @@ typedef struct uint512 {
////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef DAP_GLOBAL_IS_INT128
-
-// uint128_t dap_uint128_substract(uint128_t a, uint128_t b);
-// uint128_t dap_uint128_add(uint128_t a, uint128_t b);
-// bool dap_uint128_check_equal(uint128_t a, uint128_t b);
-// const uint128_t two_power_64={ .hi = 1, .lo = 0};
-// const uint128_t lo_64={ .hi = 0, .lo = 0xffffffffffffffff};
-// const uint128_t hi_64={ .hi = 0xffffffffffffffff, .lo = 0};
-// const uint128_t zero_128={.hi=0,.lo=0};
-// #define zero_128 ((uint128_t){.hi=0,.lo=0})
-
#define uint128_0 ((uint128_t){.hi=0,.lo=0})
#define uint128_1 ((uint128_t){.hi=0,.lo=1})
-
-// const uint64_t lo_32=0xffffffff;
-// const uint64_t hi_32=0xffffffff00000000;
-// const uint64_t ones_64=0xffffffffffffffff;
-
#else // DAP_GLOBAL_IS_INT128
-
-// #define zero_128 ((uint128_t)0)
-#define uint128_0 ((uint128_t)0)
-#define uint128_1 ((uint128_t)1)
+#define uint128_0 0ULL
+#define uint128_1 1ULL
#endif // DAP_GLOBAL_IS_INT128
-// const uint256_t zero_256={.hi=zero_128,.lo=zero_128};
-// #define zero_256 ((uint256_t){.hi=zero_128,.lo=zero_128})
#define uint256_0 ((uint256_t){.hi=uint128_0,.lo=uint128_0})
#define uint256_1 ((uint256_t){.hi=uint128_0,.lo=uint128_1})
#define uint512_0 ((uint512_t){.hi=uint256_0,.lo=uint256_0})
@@ -156,9 +131,9 @@ static inline uint128_t AND_128(uint128_t a_128_bit,uint128_t b_128_bit){
#ifdef DAP_GLOBAL_IS_INT128
return a_128_bit&b_128_bit;
-#else
+#else
uint128_t output=uint128_0;
- output.hi= a_128_bit.hi & b_128_bit.hi;
+ output.hi= a_128_bit.hi & b_128_bit.hi;
output.lo= a_128_bit.lo & b_128_bit.lo;
return output;
#endif
@@ -171,7 +146,7 @@ static inline uint128_t OR_128(uint128_t a_128_bit,uint128_t b_128_bit){
#else
uint128_t output=uint128_0;
- output.hi= a_128_bit.hi | b_128_bit.hi;
+ output.hi= a_128_bit.hi | b_128_bit.hi;
output.lo= a_128_bit.lo | b_128_bit.lo;
return output;
#endif
@@ -179,15 +154,15 @@ static inline uint128_t OR_128(uint128_t a_128_bit,uint128_t b_128_bit){
static inline uint256_t AND_256(uint256_t a_256_bit,uint256_t b_256_bit){
uint256_t output = uint256_0;
- output.hi = AND_128(a_256_bit.hi, b_256_bit.hi);
+ 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;
}
static inline uint256_t OR_256(uint256_t a_256_bit,uint256_t b_256_bit){
uint256_t output = uint256_0;
- output.hi = OR_128(a_256_bit.hi, b_256_bit.hi);
- output.lo = OR_128(a_256_bit.lo, b_256_bit.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;
}
@@ -197,8 +172,8 @@ static inline void LEFT_SHIFT_128(uint128_t a_128_bit,uint128_t* b_128_bit,int n
#ifdef DAP_GLOBAL_IS_INT128
*b_128_bit= a_128_bit << n;
-#else
- if (n >= 64) { // shifting 64-bit integer by more than 63 bits is not defined
+#else
+ if (n >= 64) { // shifting 64-bit integer by more than 63 bits is not defined
a_128_bit.hi=a_128_bit.lo;
a_128_bit.lo=0;
LEFT_SHIFT_128(a_128_bit,b_128_bit,n-64);
@@ -206,7 +181,7 @@ static inline void LEFT_SHIFT_128(uint128_t a_128_bit,uint128_t* b_128_bit,int n
if (n == 0) {
b_128_bit->hi=a_128_bit.hi;
b_128_bit->lo=a_128_bit.lo;
- }
+ }
else {
uint64_t shift_temp;
shift_temp=a_128_bit.lo<<n;
@@ -222,9 +197,9 @@ static inline void RIGHT_SHIFT_128(uint128_t a_128_bit,uint128_t* b_128_bit,int
#ifdef DAP_GLOBAL_IS_INT128
(*b_128_bit) = a_128_bit >> n;
-#else
+#else
if (n >= 64) // shifting 64-bit integer by more than 63 bits is not defined
- {
+ {
a_128_bit.lo=a_128_bit.hi;
a_128_bit.hi=0;
RIGHT_SHIFT_128(a_128_bit,b_128_bit,n-64);
@@ -233,7 +208,7 @@ static inline void RIGHT_SHIFT_128(uint128_t a_128_bit,uint128_t* b_128_bit,int
{
b_128_bit->hi=a_128_bit.hi;
b_128_bit->lo=a_128_bit.lo;
- }
+ }
else
{ uint64_t shift_temp;
shift_temp=a_128_bit.hi>>n;
@@ -245,10 +220,10 @@ static inline void RIGHT_SHIFT_128(uint128_t a_128_bit,uint128_t* b_128_bit,int
static inline void LEFT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int n){
-
+
assert (n <= 256);
- if (n >= 128) { // shifting 64-bit integer by more than 63 bits is not defined
+ if (n >= 128) { // shifting 64-bit integer by more than 63 bits is not defined
a_256_bit.hi=a_256_bit.lo;
a_256_bit.lo=uint128_0;
LEFT_SHIFT_256(a_256_bit,b_256_bit,n-128);
@@ -256,11 +231,11 @@ static inline void LEFT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int n
if (n == 0) {
b_256_bit->hi=a_256_bit.hi;
b_256_bit->lo=a_256_bit.lo;
- }
+ }
if (n<128) {
uint128_t shift_temp=uint128_0;
LEFT_SHIFT_128(a_256_bit.lo,&shift_temp,n);
- b_256_bit->lo=shift_temp;
+ b_256_bit->lo=shift_temp;
uint128_t shift_temp_or_left=uint128_0;
uint128_t shift_temp_or_right=uint128_0;
LEFT_SHIFT_128(a_256_bit.hi,&shift_temp_or_left,n);
@@ -271,7 +246,7 @@ static inline void LEFT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int n
static inline void RIGHT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int n){
assert (n <= 256);
- if (n >= 128) { // shifting 64-bit integer by more than 63 bits is not defined
+ if (n >= 128) { // shifting 64-bit integer by more than 63 bits is not defined
a_256_bit.lo=a_256_bit.hi;
a_256_bit.hi=uint128_0;
RIGHT_SHIFT_256(a_256_bit,b_256_bit,n-128);
@@ -279,11 +254,11 @@ static inline void RIGHT_SHIFT_256(uint256_t a_256_bit,uint256_t* b_256_bit,int
if (n == 0) {
b_256_bit->hi=a_256_bit.hi;
b_256_bit->lo=a_256_bit.lo;
- }
+ }
if (n<128) {
uint128_t shift_temp=uint128_0;
RIGHT_SHIFT_128(a_256_bit.hi,&shift_temp,n);
- b_256_bit->hi=shift_temp;
+ b_256_bit->hi=shift_temp;
uint128_t shift_temp_or_left=uint128_0;
uint128_t shift_temp_or_right=uint128_0;
RIGHT_SHIFT_128(a_256_bit.lo,&shift_temp_or_left,n);
@@ -297,12 +272,12 @@ static inline void INCR_128(uint128_t *a_128_bit){
#ifdef DAP_GLOBAL_IS_INT128
(*a_128_bit)++;
-#else
+#else
a_128_bit->lo++;
if(a_128_bit->lo == 0)
{
a_128_bit->hi++;
- }
+ }
#endif
}
@@ -311,12 +286,12 @@ static inline void DECR_128(uint128_t* a_128_bit){
#ifdef DAP_GLOBAL_IS_INT128
(*a_128_bit)--;
-#else
+#else
a_128_bit->lo--;
if(a_128_bit->hi == 0)
{
a_128_bit->hi--;
- }
+ }
#endif
}
@@ -327,14 +302,14 @@ static inline void INCR_256(uint256_t* a_256_bit){
if(a_256_bit->lo == 0)
{
a_256_bit->hi++;
- }
+ }
-#else
+#else
INCR_128(&a_256_bit->lo);
if(EQUAL_128(a_256_bit->lo, uint128_0))
{
INCR_128(&a_256_bit->hi);
- }
+ }
#endif
}
@@ -354,7 +329,7 @@ static inline int OVERFLOW_SUM_64_64(uint64_t a_64_bit,uint64_t b_64_bit)
}
static inline int OVERFLOW_MULT_64_64(uint64_t a_64_bit,uint64_t b_64_bit)
-{
+{
return (a_64_bit>((uint64_t)-1)/b_64_bit);
}
@@ -472,7 +447,7 @@ static inline int SUM_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t*
overflow_flag=0;
overflow_flag=SUM_128_128(carry_in_128,a_256_bit.hi,&intermediate_value);
//we store overflow_flag in case there is already overflow
- int overflow_flag_bis=0;
+ int overflow_flag_bis=0;
overflow_flag_bis=SUM_128_128(intermediate_value,b_256_bit.hi,&c_256_bit->hi);
overflow_flag=overflow_flag||overflow_flag_bis;
#endif
@@ -591,7 +566,7 @@ static inline void MULT_128_256(uint128_t a_128_bit,uint128_t b_128_bit,uint256_
//product of .hi terms - stored in .hi field of c_256_bit
MULT_64_128(a_128_bit.hi,b_128_bit.hi, &c_256_bit->hi);
- //product of .lo terms - stored in .lo field of c_256_bit
+ //product of .lo terms - stored in .lo field of c_256_bit
MULT_64_128(a_128_bit.lo,b_128_bit.lo, &c_256_bit->lo);
uint128_t cross_product_one={.hi=0, .lo=0};
@@ -607,7 +582,7 @@ static inline void MULT_128_256(uint128_t a_128_bit,uint128_t b_128_bit,uint256_
{
c_256_bit->hi.hi+=1;
}
-
+
MULT_64_128(a_128_bit.lo, b_128_bit.hi, &cross_product_two);
c_256_bit->lo.hi += cross_product_two.lo;
if(c_256_bit->lo.hi < cross_product_two.lo) // if overflowed
@@ -644,7 +619,7 @@ static inline int MULT_128_128(uint128_t a_128_bit, uint128_t b_128_bit, uint128
// incorrect
-// static inline int MULT_128_128(uint128_t a_128_bit,uint128_t b_128_bit,uint128_t* accum_128_bit) {
+// static inline int MULT_128_128(uint128_t a_128_bit,uint128_t b_128_bit,uint128_t* accum_128_bit) {
// uint64_t A=(b_128_bit.lo & lo_32)*(a_128_bit.hi & lo_32);
// uint64_t B_32_64=((b_128_bit.lo & lo_32)*(a_128_bit.hi & hi_32))&hi_32;
// uint64_t C_32_64=((b_128_bit.lo & hi_32)*(a_128_bit.hi & lo_32))&hi_32;
@@ -659,49 +634,49 @@ static inline int MULT_128_128(uint128_t a_128_bit, uint128_t b_128_bit, uint128
// int overflow_from_hi_calc=0;
// overflow_from_hi_calc=(a_128_bit.hi*b_128_bit.hi>0);
// overflow_ctr+=overflow_from_hi_calc;
-
+
// //product of two ".lo" terms
-// MULT_64_128(a_128_bit.lo,b_128_bit.lo,accum_128_bit);
+// MULT_64_128(a_128_bit.lo,b_128_bit.lo,accum_128_bit);
// int overflow=0;
// uint64_t temp=0;
-// overflow=SUM_64_64(A,temp,&accum_128_bit->hi);
+// overflow=SUM_64_64(A,temp,&accum_128_bit->hi);
// printf("accum_128_bit->hi after add in of A %" PRIu64 "\n",accum_128_bit->hi);
-
+
// overflow_ctr+=overflow;
-// temp=accum_128_bit->hi;
+// temp=accum_128_bit->hi;
// overflow=0;
-// overflow=SUM_64_64(B_32_64,temp,&accum_128_bit->hi);
+// overflow=SUM_64_64(B_32_64,temp,&accum_128_bit->hi);
// overflow_ctr+=overflow;
-// temp=accum_128_bit->hi;
+// temp=accum_128_bit->hi;
// overflow=0;
-// overflow=SUM_64_64(C_32_64,temp,&accum_128_bit->hi);
+// overflow=SUM_64_64(C_32_64,temp,&accum_128_bit->hi);
// overflow_ctr+=overflow;
-// temp=accum_128_bit->hi;
+// temp=accum_128_bit->hi;
// overflow=0;
-// overflow=SUM_64_64(E,temp,&accum_128_bit->hi);
+// overflow=SUM_64_64(E,temp,&accum_128_bit->hi);
// overflow_ctr+=overflow;
-// temp=accum_128_bit->hi;
+// temp=accum_128_bit->hi;
// overflow=0;
-// overflow=SUM_64_64(F_32_64,temp,&accum_128_bit->hi);
+// overflow=SUM_64_64(F_32_64,temp,&accum_128_bit->hi);
// overflow_ctr+=overflow;
-// temp=accum_128_bit->hi;
+// temp=accum_128_bit->hi;
// overflow=0;
-
-// overflow=SUM_64_64(G_32_64,temp,&accum_128_bit->hi);
+
+// overflow=SUM_64_64(G_32_64,temp,&accum_128_bit->hi);
// overflow_ctr+=overflow;
-// temp=accum_128_bit->hi;
+// temp=accum_128_bit->hi;
// overflow=0;
// if(overflow_ctr>0){
// overflow=1;}
// else{overflow=0;}
-
+
// return overflow;
// }
@@ -711,8 +686,8 @@ static inline void MULT_256_512(uint256_t a_256_bit,uint256_t b_256_bit,uint512_
int dummy_overflow;
//product of .hi terms - stored in .hi field of c_512_bit
MULT_128_256(a_256_bit.hi,b_256_bit.hi, &c_512_bit->hi);
-
- //product of .lo terms - stored in .lo field of c_512_bit
+
+ //product of .lo terms - stored in .lo field of c_512_bit
MULT_128_256(a_256_bit.lo,b_256_bit.lo, &c_512_bit->lo);
//cross product of .hi and .lo terms
@@ -727,21 +702,21 @@ static inline void MULT_256_512(uint256_t a_256_bit,uint256_t b_256_bit,uint512_
MULT_128_256(a_256_bit.hi,b_256_bit.lo,&cross_product_first_term);
MULT_128_256(a_256_bit.lo,b_256_bit.hi,&cross_product_second_term);
overflow=SUM_256_256(cross_product_first_term,cross_product_second_term,&cross_product);
-
-
+
+
LEFT_SHIFT_256(cross_product,&cross_product_shift_128,128); //the factor in front of cross product is 2**128
- c_512_bit_lo_copy=c_512_bit->lo;
- dummy_overflow=SUM_256_256(c_512_bit_lo_copy,cross_product_shift_128,&c_512_bit->lo);
-
- cross_product_shift_128.hi = uint128_0;
+ c_512_bit_lo_copy=c_512_bit->lo;
+ dummy_overflow=SUM_256_256(c_512_bit_lo_copy,cross_product_shift_128,&c_512_bit->lo);
+
+ cross_product_shift_128.hi = uint128_0;
cross_product_shift_128.lo = uint128_0;
RIGHT_SHIFT_256(cross_product,&cross_product_shift_128,128);
- c_512_bit_hi_copy=c_512_bit->hi;
+ c_512_bit_hi_copy=c_512_bit->hi;
dummy_overflow=SUM_256_256(c_512_bit_hi_copy,cross_product_shift_128,&c_512_bit->hi);
}
static inline int MULT_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t* accum_256_bit){
- int overflow=0;
+ int overflow=0;
int equal_flag=0;
uint512_t full_product_512={.hi=uint256_0,.lo=uint256_0,};
MULT_256_512(a_256_bit,b_256_bit,&full_product_512);
@@ -760,7 +735,7 @@ static inline int MULT_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t
// uint128_t two_0_coeff={.hi=0,.lo=0};
// MULT_64_128(a_256_bit.lo.lo,b_256_bit.lo.lo,&two_0_coeff);
// accum_256_bit->lo.lo=two_0_coeff.lo;
-
+
// uint128_t two_64_coeff={.hi=0,.lo=0};
// uint128_t two_64_coeff_one={.hi=0,.lo=0};
// MULT_64_128(a_256_bit.lo.hi,b_256_bit.lo.lo,&two_64_coeff_one);
@@ -770,7 +745,7 @@ static inline int MULT_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t
// int dummy_overflow=0;
// dummy_overflow=SUM_128_128(two_64_coeff_one,two_64_coeff_two,&two_64_coeff_sum);
// if (two_64_coeff_sum.lo+two_0_coeff.hi<two_64_coeff_sum.lo){
-
+
// two_64_coeff.lo=two_64_coeff_sum.lo+two_0_coeff.hi;
// two_64_coeff.hi=1+two_64_coeff_sum.hi;}
// else{
@@ -778,7 +753,7 @@ static inline int MULT_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t
// two_64_coeff.hi=two_64_coeff_sum.hi;
// }
// accum_256_bit->lo.hi=two_64_coeff.lo;
-
+
// uint128_t two_128_coeff={.hi=0,.lo=0};
// uint128_t two_128_coeff_one={.hi=0,.lo=0};
@@ -791,9 +766,9 @@ static inline int MULT_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t
// dummy_overflow=SUM_128_128(two_128_coeff_one,two_128_coeff_two,&two_128_coeff_sum_one);
// uint128_t two_128_coeff_sum_two={.hi=0,.lo=0};
// dummy_overflow=SUM_128_128(two_128_coeff_sum_one,two_128_coeff_three,&two_128_coeff_sum_two);
-
+
// if (two_128_coeff_sum_two.lo+two_64_coeff.hi<two_128_coeff_sum_two.lo){
-
+
// two_128_coeff.lo=two_128_coeff_sum_two.lo+two_64_coeff.hi;
// two_128_coeff.hi=1+two_128_coeff_sum_two.hi;}
// else{
@@ -825,7 +800,7 @@ static inline int MULT_256_256(uint256_t a_256_bit,uint256_t b_256_bit,uint256_t
// int overflow_two_192_coeff_sum=0;
// overflow_two_192_coeff_sum=SUM_64_64(two_192_coeff_sum_one,two_192_coeff_sum_two,&two_192_coeff);
-// return 0;
+// return 0;
// }
//#ifndef DAP_GLOBAL_IS_INT128
@@ -837,14 +812,14 @@ static inline int compare128(uint128_t a, uint128_t b)
#ifdef DAP_GLOBAL_IS_INT128
return ( a > b ? 1 : 0 ) - ( a < b ? 1 : 0 );
#else
- return (((a.hi > b.hi) || ((a.hi == b.hi) && (a.lo > b.lo))) ? 1 : 0)
+ return (((a.hi > b.hi) || ((a.hi == b.hi) && (a.lo > b.lo))) ? 1 : 0)
- (((a.hi < b.hi) || ((a.hi == b.hi) && (a.lo < b.lo))) ? 1 : 0);
#endif
}
static inline int compare256(uint256_t a, uint256_t b)
{
- return (( compare128(a.hi, b.hi) == 1 || (compare128(a.hi, b.hi) == 0 && compare128(a.lo, b.lo) == 1)) ? 1 : 0)
+ return (( compare128(a.hi, b.hi) == 1 || (compare128(a.hi, b.hi) == 0 && compare128(a.lo, b.lo) == 1)) ? 1 : 0)
- (( compare128(a.hi, b.hi) == -1 || (compare128(a.hi, b.hi) == 0 && compare128(a.lo, b.lo) == -1)) ? 1 : 0);
}
@@ -919,7 +894,7 @@ static inline void divmod_impl_128(uint128_t a_dividend, uint128_t a_divisor, ui
}
uint128_t l_denominator = a_divisor;
- uint128_t l_quotient = uint128_0;
+ uint128_t l_quotient = uint128_0;
int l_shift = fls128(a_dividend) - fls128(l_denominator);
LEFT_SHIFT_128(l_denominator, &l_denominator, l_shift);
@@ -961,7 +936,7 @@ static inline void divmod_impl_256(uint256_t a_dividend, uint256_t a_divisor, ui
}
uint256_t l_denominator = a_divisor;
- uint256_t l_quotient = uint256_0;
+ uint256_t l_quotient = uint256_0;
// int l_shift = nlz256(a_dividend) - nlz256(l_denominator);
int l_shift = fls256(a_dividend) - fls256(l_denominator);
LEFT_SHIFT_256(l_denominator, &l_denominator, l_shift);
@@ -971,7 +946,7 @@ static inline void divmod_impl_256(uint256_t a_dividend, uint256_t a_divisor, ui
if( compare256(a_dividend, l_denominator) >= 0 ) {
SUBTRACT_256_256(a_dividend, l_denominator, &a_dividend);
- l_quotient = OR_256(l_quotient, uint256_1);
+ l_quotient = OR_256(l_quotient, uint256_1);
}
RIGHT_SHIFT_256(l_denominator, &l_denominator, 1);
}
@@ -998,46 +973,11 @@ static inline void DIV_256(uint256_t a_256_bit, uint256_t b_256_bit, uint256_t*
*c_256_bit = l_ret;
}
-
-//
-// dap_uint128_substract, dap_uint128_add, dap_uint128_check_equal - temporarily, for compatibility
-static inline uint128_t dap_uint128_substract(uint128_t a, uint128_t b)
-{
- // if (a < b) {
- // return 0;
- // }
- // return a - b;
- uint128_t c = uint128_0;
- SUBTRACT_128_128(a, b, &c);
- return c;
-}
-
-/**
- * @brief dap_chain_balance_add
- * @param a
- * @param b
- * @return
- */
-static inline uint128_t dap_uint128_add(uint128_t a, uint128_t b)
-{
- // uint128_t l_ret = a + b;
- // if (l_ret < a || l_ret < b) {
- // return 0;
- // }
- // return l_ret;
- uint128_t c = uint128_0;
- SUM_128_128( a, b, &c);
- return c;
-}
-
-/**
- * @brief dap_uint128_check_equal
- * @param a
- * @param b
- * @return
- */
-static inline bool dap_uint128_check_equal(uint128_t a, uint128_t b)
+#define CONV_256_FLOAT 10000000000000ULL // 10^13, so max float number to mult is 1.000.000
+static inline uint256_t MULT_256_FLOAT(uint256_t a_val, long double a_mult)
{
- //return a == b;
- return EQUAL_128(a, b);
+ uint256_t l_ret = GET_256_FROM_64((uint64_t)(a_mult * CONV_256_FLOAT));
+ MULT_256_256(l_ret, a_val, &l_ret);
+ DIV_256(l_ret, GET_256_FROM_64(CONV_256_FLOAT), &l_ret);
+ return l_ret;
}
diff --git a/dap-sdk/core/src/android/CMakeLists.txt b/dap-sdk/core/src/android/CMakeLists.txt
index 1e9d95846f79bcecbdddf4c3debbf0d572798269..70d059ded56ed6c6f41a6afb940363248a6f18b5 100755
--- a/dap-sdk/core/src/android/CMakeLists.txt
+++ b/dap-sdk/core/src/android/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_core_android C)
diff --git a/dap-sdk/core/src/dap_common.c b/dap-sdk/core/src/dap_common.c
index f15e6cb0a91a5d1fe6c09ea96ca8c8c5a176a2cf..b2dc8c9decc0bef075392fbaf37ff645d9c9fcd6 100755
--- a/dap-sdk/core/src/dap_common.c
+++ b/dap-sdk/core/src/dap_common.c
@@ -1085,16 +1085,22 @@ void dap_usleep(time_t a_microseconds)
char* dap_ctime_r(time_t *a_time, char* a_buf){
- if (*a_time > DAP_END_OF_DAYS) {
- return "(null)\r\n";
+ char *l_fail_ret = "(null)\r\n";
+ if (!a_buf)
+ return l_fail_ret;
+ if(!a_time || *a_time > DAP_END_OF_DAYS) {
+ strcpy(a_buf, l_fail_ret);
+ return l_fail_ret;
}
struct tm l_time;
localtime_r(a_time, &l_time);
char *l_str_time = asctime_r(&l_time, a_buf);
if (l_str_time)
return l_str_time;
- else
- return "(null)\r\n";
+ else {
+ strcpy(a_buf, l_fail_ret);
+ return l_fail_ret;
+ }
}
int dap_is_alpha_and_(char e)
diff --git a/dap-sdk/core/src/dap_strfuncs.c b/dap-sdk/core/src/dap_strfuncs.c
index 08b7058d71bfc1fd22c3656f41dc049d01b8e8e8..163882b51d80daa2c00267de15f586b0afb50f7b 100755
--- a/dap-sdk/core/src/dap_strfuncs.c
+++ b/dap-sdk/core/src/dap_strfuncs.c
@@ -312,7 +312,7 @@ char* dap_strdup_vprintf(const char *a_format, va_list a_args)
* @return char* a newly-allocated string holding the result
*/
-DAP_PRINTF_ATTR(1,2) char* dap_strdup_printf(const char *a_format, ...)
+DAP_PRINTF_ATTR(1,2) char *dap_strdup_printf(const char *a_format, ...)
{
char *l_buffer;
va_list l_args;
diff --git a/dap-sdk/core/src/dap_string.c b/dap-sdk/core/src/dap_string.c
index 9016f7bfc0fcb0c332ae9aaa8c4cfd550ad25c17..e7d61347828f7033b34f99c347e0ee715c936eb1 100755
--- a/dap-sdk/core/src/dap_string.c
+++ b/dap-sdk/core/src/dap_string.c
@@ -836,10 +836,18 @@ void dap_string_append_vprintf(dap_string_t *string, const char *format, va_list
len = dap_vasprintf(&buf, format, args);
- if(len >= 0) {
+ if (len >= 0) {
dap_string_maybe_expand(string, len);
- memcpy(string->str + string->len, buf, len + 1);
- string->len += len;
+ if (string->str) {
+ memcpy(string->str + string->len, buf, len + 1);
+ string->len += len;
+ } else {
+ const char *l_mem_out = "Out of memory!";
+ const int l_fail_len = strlen(l_mem_out) + 1;
+ string->str = DAP_NEW_SIZE(char, l_fail_len);
+ strcpy(string->str, l_mem_out);
+ string->len = string->allocated_len = l_fail_len;
+ }
DAP_DELETE(buf);
}
}
diff --git a/dap-sdk/core/src/darwin/CMakeLists.txt b/dap-sdk/core/src/darwin/CMakeLists.txt
index 8f981d542da3e9b9540f764c97ee0a8fda60f7c1..651375ede9a29b1854e2e08ce329399b4981e732 100755
--- a/dap-sdk/core/src/darwin/CMakeLists.txt
+++ b/dap-sdk/core/src/darwin/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_core_darwin)
diff --git a/dap-sdk/core/src/unix/CMakeLists.txt b/dap-sdk/core/src/unix/CMakeLists.txt
index 828fdfb757ca7c653c734c5caeb69b2621b1adfb..1e7ae9443e95046b8352320edbe9bb50ebd3a6c6 100755
--- a/dap-sdk/core/src/unix/CMakeLists.txt
+++ b/dap-sdk/core/src/unix/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_core_unix)
diff --git a/dap-sdk/core/src/win32/CMakeLists.txt b/dap-sdk/core/src/win32/CMakeLists.txt
index f3d0c43a6662887771ccebe815b8f8102824b6e1..6f84da809b91ab4cc25fffd5a5dd135f41907414 100644
--- a/dap-sdk/core/src/win32/CMakeLists.txt
+++ b/dap-sdk/core/src/win32/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_core_win32 C)
diff --git a/dap-sdk/core/test/CMakeLists.txt b/dap-sdk/core/test/CMakeLists.txt
index c9ef63ebb3d691543f98993ee2483497de6301c9..47f257f342a8b098a8552a7e6f2e0ee71aeecc40 100755
--- a/dap-sdk/core/test/CMakeLists.txt
+++ b/dap-sdk/core/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(core_test)
diff --git a/dap-sdk/core/test/uint256_t/unit_test.cpp b/dap-sdk/core/test/uint256_t/unit_test.cpp
index 064d0810b93503a3313483aa2a7f81fc1d57f807..ac4371c00f3453e25c9e2b960ae34416a03eed21 100644
--- a/dap-sdk/core/test/uint256_t/unit_test.cpp
+++ b/dap-sdk/core/test/uint256_t/unit_test.cpp
@@ -39,17 +39,17 @@ int main()
int error_counter_sum_64_128=0;
- uint128_t dap_test_128_shift=uint128_0;
- uint128_t dap_test_128_one=uint128_0;
- uint128_t dap_test_128_two=uint128_0;
- uint128_t dap_test_128_sub=uint128_0;
- uint256_t dap_test_256_one=uint256_0;
- uint256_t dap_test_256_two=uint256_0;
- uint256_t dap_test_256_sum=uint256_0;
- uint256_t dap_test_256_sub=uint256_0;
- uint256_t dap_test_256_prod=uint256_0;
- uint256_t dap_test_256_shift=uint256_0;
- uint512_t dap_test_512_prod=uint512_0;
+ uint128_t dap_test_128_shift={.hi=0, .lo=0};
+ uint128_t dap_test_128_one={.hi=0, .lo=0};
+ uint128_t dap_test_128_two={.hi=0, .lo=0};
+ uint128_t dap_test_128_sub={.hi=0, .lo=0};
+ uint256_t dap_test_256_one={.hi=zero_128, .lo=zero_128};
+ uint256_t dap_test_256_two={.hi=zero_128, .lo=zero_128};
+ uint256_t dap_test_256_sum={.hi=zero_128, .lo=zero_128};
+ uint256_t dap_test_256_sub={.hi=zero_128, .lo=zero_128};
+ uint256_t dap_test_256_prod={.hi=zero_128, .lo=zero_128};
+ uint256_t dap_test_256_shift={.hi=zero_128, .lo=zero_128};
+ uint512_t dap_test_512_prod={.hi=zero_256, .lo=zero_256};
int overflow_flag;
int overflow_flag_prod;
int borrow_flag_128;
@@ -308,8 +308,8 @@ if (division_enabled==1){
prod_256_256_file << density_index << std::endl;}
/////////////////////output of 256*256-->512//////////////////////
- dap_test_512_prod.lo=uint256_0;
- dap_test_512_prod.hi=uint256_0;
+ dap_test_512_prod.lo=zero_256;
+ dap_test_512_prod.hi=zero_256;
uint256_t intermed_lo_prod;
uint256_t intermed_hi_prod;
MULT_128_256(dap_test_256_one.lo,dap_test_256_two.lo,&intermed_lo_prod);
@@ -442,8 +442,8 @@ if (division_enabled==1){
dap_test_128_256_prod_one.hi=j;
dap_test_128_256_prod_two.lo=max_64-(i+1);
dap_test_128_256_prod_two.hi=max_64-2*(j+1);
- dap_test_128_256_prod_prod.lo=uint128_0;
- dap_test_128_256_prod_prod.hi=uint128_0;
+ dap_test_128_256_prod_prod.lo=zero_128;
+ dap_test_128_256_prod_prod.hi=zero_128;
boost::multiprecision::uint256_t boost_test_128_256_prod;
boost::multiprecision::uint128_t boost_test_128_256_one;
diff --git a/dap-sdk/crypto/CMakeLists.txt b/dap-sdk/crypto/CMakeLists.txt
index 3badd0046895a28ec855633f5e2ba59e44263a7f..91dd01a80a3599e41c81b28cd1c5e35f500d0e70 100755
--- a/dap-sdk/crypto/CMakeLists.txt
+++ b/dap-sdk/crypto/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_crypto)
# fix implicit declaration warnings
diff --git a/dap-sdk/crypto/include/dap_cert.h b/dap-sdk/crypto/include/dap_cert.h
index 0dee3bf8858f543c7878ac73e8eaf341be497b25..ee526e8649a01c2fc532e09c2f0e645266d8e8d6 100755
--- a/dap-sdk/crypto/include/dap_cert.h
+++ b/dap-sdk/crypto/include/dap_cert.h
@@ -45,7 +45,7 @@ typedef enum dap_cert_metadata_type {
typedef struct dap_cert_metadata {
const char *key;
uint32_t length;
- dap_cert_metadata_type_t type : 8;
+ dap_cert_metadata_type_t type;
byte_t value[];
} dap_cert_metadata_t;
diff --git a/dap-sdk/crypto/include/dap_hash.h b/dap-sdk/crypto/include/dap_hash.h
index 0f152542f8305978e755706e5a41bd7560ff4c8d..73b0c3a2869e0d07e8603766c0c678cbd453a7c5 100755
--- a/dap-sdk/crypto/include/dap_hash.h
+++ b/dap-sdk/crypto/include/dap_hash.h
@@ -93,6 +93,14 @@ static inline bool dap_hash_fast_compare(dap_hash_fast_t *a_hash1, dap_hash_fast
return false;
}
+/**
+ * @brief
+ * compare hash with blank hash
+ * @param a_hash
+ * @return true
+ * @return false
+ */
+
static inline bool dap_hash_fast_is_blank( dap_hash_fast_t *a_hash )
{
static dap_hash_fast_t l_blank_hash = {};
diff --git a/dap-sdk/crypto/include/dap_pkey.h b/dap-sdk/crypto/include/dap_pkey.h
index 56805e565e327460c4dc7aaa1e29b0e82a55c427..93040b6a0617ccb2b2178826787c81ff27ac6c4e 100755
--- a/dap-sdk/crypto/include/dap_pkey.h
+++ b/dap-sdk/crypto/include/dap_pkey.h
@@ -37,9 +37,10 @@ enum dap_pkey_type_enum {
PKEY_TYPE_MULTI = 0xffff /// @brief Has inside subset of different keys
};
+typedef uint16_t dap_pkey_type_enum_t;
typedef union dap_pkey_type{
- enum dap_pkey_type_enum type: 16;
+ dap_pkey_type_enum_t type;
uint16_t raw;
} dap_pkey_type_t;
diff --git a/dap-sdk/crypto/include/dap_sign.h b/dap-sdk/crypto/include/dap_sign.h
index 4018361a65e70323cda9cb9aca0a741a0ca4b53c..23d13c366641c28d3f6f0bae351bdc3f2c1a92b2 100755
--- a/dap-sdk/crypto/include/dap_sign.h
+++ b/dap-sdk/crypto/include/dap_sign.h
@@ -32,7 +32,7 @@
#include "dap_hash.h"
#include "dap_string.h"
-typedef enum {
+enum dap_sign_type_enum {
SIG_TYPE_NULL = 0x0000,
SIG_TYPE_BLISS = 0x0001,
SIG_TYPE_DEFO = 0x0002, /// @brief key image for anonymous transaction
@@ -41,10 +41,11 @@ typedef enum {
SIG_TYPE_DILITHIUM = 0x0102, /// @brief
SIG_TYPE_MULTI_CHAINED = 0x0f00, /// @brief Has inside subset of different signatures and sign composed with all of them
SIG_TYPE_MULTI_COMBINED = 0x0f01 /// @brief Has inside subset of different public keys and sign composed with all of appropriate private keys
-} dap_sign_type_enum_t;
+};
+typedef uint32_t dap_sign_type_enum_t;
typedef union dap_sign_type {
- dap_sign_type_enum_t type: 32;
+ dap_sign_type_enum_t type;
uint32_t raw;
} DAP_ALIGN_PACKED dap_sign_type_t;
diff --git a/dap-sdk/crypto/src/dap_enc_dilithium.c b/dap-sdk/crypto/src/dap_enc_dilithium.c
index bf6ddd748c24db928c2f96e2a2eb4e8e059c5dd7..bf35a074976241b0fa7add50ee1eae2f9d3b4f7f 100755
--- a/dap-sdk/crypto/src/dap_enc_dilithium.c
+++ b/dap-sdk/crypto/src/dap_enc_dilithium.c
@@ -88,7 +88,7 @@ size_t dap_enc_sig_dilithium_verify_sign(struct dap_enc_key * key, const void *
if( l_ret != 0)
log_it(L_WARNING,"Wrong signature, can't open with code %d", l_ret);
- return l_ret>0? l_ret : 0;
+ return l_ret < 0 ? l_ret : 0;
}
void dap_enc_sig_dilithium_key_delete(struct dap_enc_key * key)
diff --git a/dap-sdk/crypto/src/dap_enc_tesla.c b/dap-sdk/crypto/src/dap_enc_tesla.c
index a67cb0618fe84f26f2ebc8c86304d56a8e6b1057..54e40d2e09639b0d264d6fee6e38040453170db6 100755
--- a/dap-sdk/crypto/src/dap_enc_tesla.c
+++ b/dap-sdk/crypto/src/dap_enc_tesla.c
@@ -94,7 +94,7 @@ size_t dap_enc_sig_tesla_verify_sign(struct dap_enc_key * key, const void * msg,
{
if(signature_size < sizeof(tesla_signature_t)) {
log_it(L_ERROR, "bad signature size");
- return 0;
+ return -6;
}
return (tesla_crypto_sign_open((tesla_signature_t *) signature, (unsigned char *) msg, msg_size, key->pub_key_data));
diff --git a/dap-sdk/crypto/src/dap_pkey.c b/dap-sdk/crypto/src/dap_pkey.c
index 4a62c3820887fc8789e959f59a57c8ee436f1bf2..a8a40a9ecbce9576cad556911291cc4965543abe 100755
--- a/dap-sdk/crypto/src/dap_pkey.c
+++ b/dap-sdk/crypto/src/dap_pkey.c
@@ -30,9 +30,10 @@
/**
- * @brief dap_pkey_from_enc_key
- * @param a_key
- * @return
+ * @brief
+ * convert encryption key to public key
+ * @param a_key dap_enc_key_t encryption key
+ * @return dap_pkey_t*
*/
dap_pkey_t* dap_pkey_from_enc_key(dap_enc_key_t *a_key)
{
@@ -51,9 +52,10 @@ dap_pkey_t* dap_pkey_from_enc_key(dap_enc_key_t *a_key)
/**
* @brief dap_pkey_from_enc_key_output
- * @param a_key
- * @param a_output
- * @return
+ * convert encryption key to public key and placed it in output buffer
+ * @param a_key dap_enc_key_t encryption key object
+ * @param a_output output data
+ * @return result
*/
int dap_pkey_from_enc_key_output(dap_enc_key_t *a_key, void * a_output)
{
diff --git a/dap-sdk/crypto/src/dap_sign.c b/dap-sdk/crypto/src/dap_sign.c
index 2582d4b1c3a29452a9c377a8c96ef986ae510074..7c64420b0b4202cb9cbf8d8a7a5a3e0332b0667b 100755
--- a/dap-sdk/crypto/src/dap_sign.c
+++ b/dap-sdk/crypto/src/dap_sign.c
@@ -410,7 +410,7 @@ int dap_sign_verify(dap_sign_t * a_chain_sign, const void * a_data, const size_t
case DAP_ENC_KEY_TYPE_SIG_TESLA:
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- if(l_key->dec_na(l_key, a_data, a_data_size, l_sign_data, l_sign_data_size) > 0)
+ if(l_key->dec_na(l_key, a_data, a_data_size, l_sign_data, l_sign_data_size) < 0)
l_ret = 0;
else
l_ret = 1;
diff --git a/dap-sdk/crypto/test/CMakeLists.txt b/dap-sdk/crypto/test/CMakeLists.txt
index fe129624464d805d51780fd653889e6425e914f9..725414756091afb244a9dbd1388c033f7a485628 100755
--- a/dap-sdk/crypto/test/CMakeLists.txt
+++ b/dap-sdk/crypto/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(test)
set(CMAKE_C_STANDARD 11)
diff --git a/dap-sdk/crypto/test/crypto/CMakeLists.txt b/dap-sdk/crypto/test/crypto/CMakeLists.txt
index cc132aa8dd3e4a68b24946930966c1bd3aa5de94..ef6afe9d0c1c79ae3e28bd09486a1975e0631996 100755
--- a/dap-sdk/crypto/test/crypto/CMakeLists.txt
+++ b/dap-sdk/crypto/test/crypto/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(crypto-test)
# init CellFrame SDK
@@ -7,20 +7,22 @@ set(SUBMODULES_NO_BUILD ON)
include (cellframe-sdk/cmake/OS_Detection.cmake)
set(DAPSDK_MODULES "core crypto network-core network-client network-server")
-if( DARWIN)
- add_subdirectory(cellframe-sdk/3rdparty/json-c-darwin)
- add_subdirectory(cellframe-sdk/3rdparty/libmagic-darwin)
- include_directories(cellframe-sdk/3rdparty/json-c-darwin)
-endif()
-if (ANDROID)
- add_subdirectory(cellframe-sdk/3rdparty/libmagic)
- add_subdirectory(cellframe-sdk/3rdparty/json-c)
- include_directories(cellframe-sdk/cellframe-sdk/3rdparty/)
-endif()
+# There is no need, as it was added in cellframe-sdk/CMakeLists.txt
+
+#if( DARWIN)
+# add_subdirectory(cellframe-sdk/3rdparty/json-c-darwin)
+# add_subdirectory(cellframe-sdk/3rdparty/libmagic-darwin)
+# include_directories(cellframe-sdk/3rdparty/json-c-darwin)
+#endif()
+#if (ANDROID)
+# add_subdirectory(cellframe-sdk/3rdparty/libmagic)
+# add_subdirectory(cellframe-sdk/3rdparty/json-c)
+# include_directories(cellframe-sdk/cellframe-sdk/3rdparty/)
+#endif()
#add_subdirectory(cellframe-sdk/dap-sdk)
#enable_testing()
-add_subdirectory(test)
+#add_subdirectory(test)
if ( NOT ( TARGET dap_core ) )
diff --git a/dap-sdk/crypto/test/crypto/dap_enc_ringct20_test.c b/dap-sdk/crypto/test/crypto/dap_enc_ringct20_test.c
index 6ee4936839b488158c4c1e35ea686fb8aab516cb..baa0e819b69b5b7ac34dab2c11ba9349e8210be7 100644
--- a/dap-sdk/crypto/test/crypto/dap_enc_ringct20_test.c
+++ b/dap-sdk/crypto/test/crypto/dap_enc_ringct20_test.c
@@ -3,6 +3,404 @@
#include "ringct20/ringct20_params.h"
#include "rand/dap_rand.h"
+#define MSIZE 2
+#define WSIZE 3
+#define NSIZE 3
+
+// From original implementation https://github.com/chainchip/Lattice-RingCT-v2.0/blob/master/Ring2.0/ring_test.c
+
+void LRCT_Byte_Test()
+{
+ poly_ringct20 a, ra;
+ uint8_t seed[NEWHOPE_RINGCT20_SYMBYTES] = { 0 };
+ unsigned char bCof[NEWHOPE_RINGCT20_POLYBYTES] = { 0 };
+ randombytes(seed, NEWHOPE_RINGCT20_SYMBYTES);
+ poly_uniform_ringct20(&a, seed);
+// printf("begin:\n");
+// poly_print(&a);
+// printf("serial:\n");
+ poly_serial(&a);
+// poly_print(&a);
+ poly_tobytes(bCof, &a);
+// printf("ra:\n");
+ poly_frombytes(&ra, bCof);
+// poly_print(&ra);
+
+
+}
+
+void LRCT_Setup_Test()
+{
+ poly_ringct20 A[2], H[2];
+ poly_ringct20 S[2];
+ poly_ringct20 L[2];
+ poly_ringct20 h;
+ poly_ringct20 u[3];
+ poly_ringct20 c1;
+ poly_ringct20* t[2];
+ unsigned char msg[2] = { 0x01, 0x02 };
+ unsigned char msg2[2] = { 0x02, 0x03 };
+ int msgLen = 2;
+ unsigned char bt[NEWHOPE_RINGCT20_POLYBYTES] = { 0 };
+ size_t mLen = 2;
+ size_t i = 0;
+ size_t k = 0;
+ int result = 0;
+ int w = 2;
+ int pai = 1;
+
+ t[0] = (poly_ringct20 *)malloc((3) * sizeof(poly_ringct20));
+ t[1] = (poly_ringct20 *)malloc((3) * sizeof(poly_ringct20));
+
+ for (i = 0; i < 2; i++)
+ {
+ for (k = 0; k < 3; k++)
+ {
+ poly_init(t[i] + k);
+ }
+
+ }
+ LRCT_Setup(A, H, 2);
+ LRCT_SampleKey(S, 2);
+ LRCT_KeyGen(L, A, S, 2);
+ LRCT_SampleKey(S, 2);
+ LRCT_KeyGen(L+1, A, S, 2);
+
+ for (k = 0; k < 3; k++)
+ {
+ randombytes(bt, NEWHOPE_RINGCT20_POLYBYTES);
+ poly_frombytes(u + k, bt);
+ poly_serial(u + k);
+ ///poly_print(u+k);
+ }
+// printf("====================================\n");
+ LRCT_SigGen(&c1, t, &h, A, H,S, u, mLen, L, w,pai, msg, msgLen);
+// printf("c1\n");
+// poly_print(&c1);
+// printf("=================\n");
+ result = LRCT_SigVer(&c1, t, A, H, mLen, &h, L,w, msg, msgLen);
+ dap_assert_PIF(result == 1, "Sign Verify");
+ result = LRCT_SigVer(&c1, t, A, H, mLen, &h, L, w, msg2, msgLen);
+ dap_assert_PIF(result != 1, "Sign Verify");
+ free(t[0]);
+ free(t[1]);
+
+}
+
+void MIMO_LRCT_Setup_Test()
+{
+ poly_ringct20 A[MSIZE], H[MSIZE];
+ poly_ringct20 SList[MSIZE*NSIZE];
+ poly_ringct20 S[MSIZE];
+ poly_ringct20 LList[NSIZE*WSIZE];
+ poly_ringct20 hList[NSIZE];
+ poly_ringct20 c1;
+ poly_ringct20 tList[NSIZE*WSIZE*(MSIZE+1)];
+ int i, j, k;
+ int pai = 2;
+ unsigned char msg[2] = { 0x01, 0x02 };
+ unsigned char msg2[2] = { 0x01, 0x03 };
+ int msgLen = 2;
+ int result = 0;
+ MIMO_LRCT_Setup(A, H, MSIZE);
+ for ( i = 0; i < NSIZE; i++)
+ {
+ LRCT_SampleKey(SList + i*MSIZE, MSIZE);
+ MIMO_LRCT_KeyGen(LList + i*WSIZE + (pai-1) , A, SList + i * MSIZE, MSIZE);
+ }
+ for ( i = 0; i < WSIZE; i++)
+ {
+ if (i != pai-1)
+ {
+ for (j = 0; j < NSIZE; j++)
+ {
+ LRCT_SampleKey(S, MSIZE);
+ MIMO_LRCT_KeyGen(LList + j* WSIZE + i, A, S, MSIZE);
+ }
+ }
+
+ }
+ MIMO_LRCT_SigGen(&c1, tList, hList, SList, NSIZE, A, H, MSIZE, LList, WSIZE, pai, msg, msgLen);
+ result = MIMO_LRCT_SigVer(&c1, tList, hList, NSIZE, A, /*H,*/ MSIZE, LList, WSIZE, msg, msgLen);
+ dap_assert_PIF(result == 1, "Sign verify");
+ result = MIMO_LRCT_SigVer(&c1, tList, hList, NSIZE, A, /*H,*/ MSIZE, LList, WSIZE, msg2, msgLen);
+ dap_assert_PIF(result != 1, "Sign verify");
+}
+
+void LRCT_Spent_Test()
+{
+ poly_ringct20 A[MSIZE], H[MSIZE];
+ poly_ringct20 skPai[MSIZE], pkPai;
+ poly_ringct20 ckPai[MSIZE];
+ poly_ringct20* t[WSIZE];
+ unsigned char bMessage[4] = { 0x01, 0x02, 0x03, 0x4 };
+ size_t msglen = 4;
+ IW iw;
+ //////////////////
+ poly_ringct20 skOA[MSIZE];
+ poly_ringct20 pkOA;
+ IW iwOA;
+ poly_ringct20 ckOA[MSIZE];
+ ////////////////////
+ IW iwList[WSIZE];
+ poly_ringct20 skTmp[MSIZE];
+ poly_ringct20 pkList[WSIZE];
+ poly_ringct20 ckList[WSIZE][MSIZE];
+ unsigned char bListMessage[2] = { 0x01, 0x02};
+ size_t msgListlen = 2;
+ int i = 0;
+ ///////////////////
+ poly_ringct20 L[WSIZE];
+ int paiIndex = 1;
+ poly_ringct20 c1, h;
+ unsigned char bSignMessage[3] = { 0x01, 0x02, 0x03 };
+ size_t msgSignlen = 3;
+ int result =0;
+ size_t k = 0;
+ /////////////////
+ for ( i = 0; i < WSIZE; i++)
+ {
+ t[i] = (poly_ringct20 *)malloc((MSIZE+1) * sizeof(poly_ringct20));
+ for (k = 0; k < MSIZE+1; k++)
+ {
+ poly_init(t[i] + k);
+ }
+ }
+ ///////////////////
+ LRCT_Setup(A, H, MSIZE);
+ LRCT_SampleKey(skPai, MSIZE);
+ LRCT_KeyGen(&pkPai, A, skPai, MSIZE);//A*S+0
+ LRCT_Mint(&iw, ckPai, &pkPai, A, MSIZE, bMessage, msglen);//A*ck + $
+ ///
+ LRCT_SampleKey(skOA, MSIZE);
+ LRCT_KeyGen(&pkOA, A, skOA, MSIZE);//
+ //LRCT_Mint(&iwOA, ckOA, &pkOA, A, MSIZE, bMessage, msglen);
+ //////
+ for( i = 0; i < WSIZE; i++)
+ {
+ if (i == paiIndex)
+ {
+ poly_cofcopy(&iwList[i].a, &iw.a);
+ poly_cofcopy(&iwList[i].cn, &iw.cn);
+ }
+ else
+ {
+ LRCT_SampleKey(skTmp, MSIZE);
+ LRCT_KeyGen(pkList + i, A, skTmp, MSIZE);//A*S+0
+ LRCT_Mint(iwList + i, ckList[i], pkList + i, A, MSIZE, bListMessage, msgListlen);
+ }
+
+ }
+ LRCT_Spend(&iwOA, ckOA, &c1, t, &h, L, bSignMessage, msgSignlen, iwList, WSIZE, paiIndex, skPai, ckPai, bMessage, msglen, &pkOA, A, H, MSIZE);
+ result = LRCT_Verify(&c1, t, &h, A, H, MSIZE, bSignMessage, msgSignlen, L, WSIZE);
+ dap_assert_PIF(result == 1, "Sign Verify");
+ for (i = 0; i < WSIZE; i++)
+ {
+ free(t[i]);
+ }
+}
+
+
+void LRCT_Mul_Test()
+{
+ poly_ringct20 A[2], H[2], H2[2];
+ poly_ringct20 h,h1,r;
+ poly_ringct20 S[2];
+ LRCT_Setup(A, H, 2);
+ LRCT_SampleKey(S, 2);
+
+ LRCT_MatrixMulPoly(&h, H, S, 2);
+
+
+ for (size_t i = 0; i < NEWHOPE_RINGCT20_N; i++)
+ {
+ h.coeffs[i] = coeff_freeze2Q(NEWHOPE_RINGCT20_2Q + NEWHOPE_RINGCT20_Q - h.coeffs[i] * 2);
+ }
+ LRCT_ConstMulMatrix(H2, H, 2, 2);
+ LRCT_MatrixMulPoly(&h1, H2, S, 2);
+ poly_add_ringct20(&r, &h1, &h);
+// poly_print(&r);
+
+
+}
+void LRCT_MatrixMulVect_Test()
+{
+ poly_ringct20 A[2], H[2];
+ LRCT_Setup(A, H, 2);
+ uint8_t bt[2] = { 0 };
+ bt[0] = 1;
+ bt[1] = 2;
+
+
+}
+void LRCT_Lift_Test()
+{
+ poly_ringct20 A[2], H[2], LA[3], H2[3];
+ poly_ringct20 h;
+ poly_ringct20 S[2];
+ LRCT_SampleKey(S, 2);
+ LRCT_Setup(A, H, 2);
+ LRCT_MatrixMulPoly(&h, H, S, 2);
+ LRCT_Lift(LA, H, &h, 2);
+ ////////////////////////////////////
+ LRCT_ConstMulMatrix(H2, H, 2, 2);
+ for (size_t i = 0; i < NEWHOPE_RINGCT20_N; i++)
+ {
+ H2[2].coeffs[i] = coeff_freeze2Q(NEWHOPE_RINGCT20_2Q + NEWHOPE_RINGCT20_Q - h.coeffs[i] * 2);
+ }
+ for (size_t i = 0; i < 3; i++)
+ {
+ dap_assert_PIF(poly_equal(LA + i, H2 + i) == 1, "Poly equality");
+ }
+}
+void LRCT_KDF_Test()
+{
+
+}
+
+void LRCT_Com_Test()
+{
+ IW iw;
+ poly_ringct20 ck[2];
+ size_t mLen = 2;
+ poly_ringct20 A[2], H[2], sk[2];
+ unsigned char bMessage[4] = { 0x01, 0x02, 0x03, 0x4 };
+ size_t msglen = 4;
+ poly_ringct20 a;
+ LRCT_Setup(A, H, mLen);
+ LRCT_SampleKey(sk, mLen);
+ LRCT_KeyGen(&a, A, sk, mLen);
+// printf("public key:");
+// poly_print(&a);
+ LRCT_Mint(&iw, ck, &a, A, mLen, bMessage, msglen);
+// printf("a:\n");
+// poly_print(&(iw.a));
+// printf("cn:\n");
+// poly_print(&(iw.cn));
+}
+//ntt å˜æ¢æµ‹è¯•
+void LRCT_Fun_Test()
+{
+ uint8_t seed[NEWHOPE_RINGCT20_SYMBYTES] = { 0 };
+ poly_ringct20 a;
+ randombytes(seed, NEWHOPE_RINGCT20_SYMBYTES);
+ poly_uniform_ringct20(&a, seed);
+ poly_serial(&a);
+ ////////////
+// printf("begin:\n");
+// poly_print(&a);
+ //////
+ poly_ntt_ringct20(&a);
+// printf("after:\n");
+// poly_print(&a);
+ ////
+ poly_invntt(&a);
+// printf("recover:\n");
+// poly_print(&a);
+
+}
+//移ä½æµ‹è¯•
+void LRCT_Shift_Test()
+{
+ poly_ringct20 r, a;
+ poly_init(&r);
+ poly_init(&a);
+ r.coeffs[NEWHOPE_RINGCT20_N - 1] = 1;
+ r.coeffs[0] = 1;
+
+ poly_ntt_ringct20(&r);
+ poly_shift(&a, &r, 1);
+ poly_invntt(&a);
+
+ poly_serial(&a);
+// poly_print(&a);
+}
+void LRCT_ComHom_Test()
+{
+ unsigned char message[2] = { 0xF0, 0x0F };
+ int messLen = 2;
+ int messBitLen = messLen*8;
+ int i = 0;
+ unsigned char bitTmp = 0;
+ poly_ringct20 *CKi = (poly_ringct20 *)malloc((MSIZE*(messBitLen)) * sizeof(poly_ringct20));
+ poly_ringct20 *comList = (poly_ringct20 *)malloc(((messBitLen)) * sizeof(poly_ringct20));
+ poly_ringct20 A[MSIZE], H[MSIZE], sk[MSIZE], ck0[MSIZE], tmpM[MSIZE];
+ poly_ringct20 a, r, tmp;
+
+ poly_init(&a);
+ poly_init(&tmp);
+ poly_init(&r);
+ for ( i = 0; i < MSIZE; i++)
+ {
+ poly_init(ck0 + i);
+ }
+ LRCT_Setup(A, H, MSIZE);
+ LRCT_SampleKey(sk, MSIZE);
+ //left
+ LRCT_nttCom(&r, A, sk, MSIZE, message, messLen);
+ //right
+ for (i = 1; i < messBitLen; i++)
+ {
+ LRCT_SampleKey(CKi + i*MSIZE, MSIZE);
+ }
+
+ LRCT_GetCK0(CKi, sk, MSIZE, CKi+MSIZE, messBitLen-1);
+
+ for ( i = 0; i < messBitLen; i++)
+ {
+ LRCT_MatrixShift(tmpM, CKi+i*MSIZE, MSIZE, i);
+ LRCT_MatrixAddMatrix(ck0, ck0, tmpM, MSIZE);
+ }
+ for ( i = 0; i < MSIZE; i++)
+ {
+ dap_assert_PIF(poly_equal(ck0 + i, sk + i) == 1, "poly equality")
+ }
+
+ for ( i = 0; i < messLen; i++)
+ {
+ bitTmp = (message[i] & 0x01);
+ LRCT_nttCom(comList + i * 8, A, CKi + (i * 8) * MSIZE, MSIZE, &bitTmp, 1);
+ //////////////////////////////
+ bitTmp = (message[i] & 0x02)>>1;
+ LRCT_nttCom(comList + i * 8 + 1, A, CKi + (i * 8 + 1) * MSIZE, MSIZE, &bitTmp, 1);
+ ////////////
+ bitTmp = (message[i] & 0x04)>>2;
+ LRCT_nttCom(comList + i * 8 + 2, A, CKi + (i * 8 + 2) * MSIZE, MSIZE, &bitTmp, 1);
+ ////////////
+ bitTmp = (message[i] & 0x08)>>3;
+ LRCT_nttCom(comList + i * 8 + 3, A, CKi + (i * 8 + 3) * MSIZE, MSIZE, &bitTmp, 1);
+
+ ////////////
+ bitTmp = (message[i] & 0x10)>>4;
+ LRCT_nttCom(comList + i * 8 + 4, A, CKi + (i * 8 + 4) * MSIZE, MSIZE, &bitTmp, 1);
+
+ ////////////
+ bitTmp = (message[i] & 0x20)>>5;
+ LRCT_nttCom(comList + i * 8 + 5, A, CKi + (i * 8 + 5) * MSIZE, MSIZE, &bitTmp, 1);
+
+ ////////////
+ bitTmp = (message[i] & 0x40)>>6;
+ LRCT_nttCom(comList + i * 8 + 6, A, CKi + (i * 8 + 6) * MSIZE, MSIZE, &bitTmp, 1);
+
+ ////////////
+ bitTmp = (message[i] & 0x80)>>7;
+ LRCT_nttCom(comList + i * 8 + 7, A, CKi + (i * 8 + 7) * MSIZE, MSIZE, &bitTmp, 1);
+ }
+ //poly_cofcopy(&a, comList);
+ for ( i = 0; i < messBitLen; i++)
+ {
+ poly_shift(&tmp, comList + i, i);
+ poly_add_ringct20(&a, &a, &tmp);
+ }
+// printf("a:\n");
+// poly_print(&a);
+// printf("r:\n");
+// poly_print(&r);
+ dap_assert_PIF(poly_equal(&a, &r) == 1, "poly equality");
+ free(CKi);
+ free(comList);
+}
+
static void test_signing_verifying2(void)
{
@@ -14,6 +412,7 @@ static void test_signing_verifying2(void)
randombytes(seed, seed_size);
+ // one keypair
dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_SIG_RINGCT20, NULL, 0, seed, seed_size, 0);
const int allpbknum = 100;
@@ -37,7 +436,8 @@ static void test_signing_verifying2(void)
dap_assert_PIF(siglen > 0, "Signing message");
//Extract aList//CRUTCH
- uint8_t *sigdata = (uint8_t*)*(int*)(sig + 4);
+// uint8_t *sigdata = (uint8_t*)*(int*)(sig + 4);
+ uint8_t *sigdata = (uint8_t*) ((ringct20_signature_t*) sig)->sig_data;
// for(int i = 0; i < 16; ++i)
// printf("%.2x ", sigdata[i]);
// printf(" = sig_extract\n"); fflush(stdout);
@@ -155,8 +555,44 @@ void dap_enc_ringct20_tests_run(const int times)
dap_print_module_name("dap_enc_ringct20");
init_test_case();
char print_buf[512];
- snprintf(print_buf, sizeof(print_buf), "Signing and verifying message %d time", times);
+ snprintf(print_buf, sizeof(print_buf), "Byte test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Byte_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Signing and verifying message SISO mode %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Setup_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Signing and verifying message MIMO mode %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(MIMO_LRCT_Setup_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Spent test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Spent_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Mul test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Mul_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "MatrixMulVect test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_MatrixMulVect_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Lift test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Lift_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "KDF test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_KDF_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Com test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Com_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Fun test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Fun_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Shift test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_Shift_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "ComHom test %d time", times);
+ benchmark_mgs_time(print_buf, benchmark_test_time(LRCT_ComHom_Test, times));
+
+ snprintf(print_buf, sizeof(print_buf), "Signing and verifying message %d time", times);
benchmark_mgs_time(print_buf, benchmark_test_time(test_signing_verifying2, times));
cleanup_test_case();
diff --git a/dap-sdk/crypto/test/crypto/dap_enc_test.c b/dap-sdk/crypto/test/crypto/dap_enc_test.c
index 12e46f001591dbd6f92ece43288f513c7cc38da8..16ad86be882190c2a2391d626b9b3445321e9060 100755
--- a/dap-sdk/crypto/test/crypto/dap_enc_test.c
+++ b/dap-sdk/crypto/test/crypto/dap_enc_test.c
@@ -468,7 +468,7 @@ void dap_enc_tests_run() {
dap_print_module_name("dap_enc_sig serealize->deserealize BLISS");
test_serealize_deserealize_pub_priv(DAP_ENC_KEY_TYPE_SIG_BLISS);
dap_print_module_name("dap_enc_sig serealize->deserealize PICNIC");
- test_serealize_deserealize_pub_priv(DAP_ENC_KEY_TYPE_SIG_PICNIC);
+ test_serealize_deserealize_pub_priv(DAP_ENC_KEY_TYPE_SIG_PICNIC); //sometimes fail
dap_print_module_name("dap_enc_sig serealize->deserealize TESLA");
test_serealize_deserealize_pub_priv(DAP_ENC_KEY_TYPE_SIG_TESLA);
dap_print_module_name("dap_enc_sig serealize->deserealize DILITHIUM");
diff --git a/dap-sdk/net/client/CMakeLists.txt b/dap-sdk/net/client/CMakeLists.txt
index 39185cc300f9dfda0ef43ae046d0adc278dbd018..4c1645ab84c8b52b1adb456dca7bc21175fba756 100644
--- a/dap-sdk/net/client/CMakeLists.txt
+++ b/dap-sdk/net/client/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(dap_client)
add_definitions ("-D_GNU_SOURCE")
diff --git a/dap-sdk/net/client/dap_client.c b/dap-sdk/net/client/dap_client.c
index d9d364beaf5d2bb1c498295604df628dcb1548f2..89d098685ebe254624151aa3682b8fed7db2578a 100644
--- a/dap-sdk/net/client/dap_client.c
+++ b/dap-sdk/net/client/dap_client.c
@@ -177,46 +177,6 @@ uint16_t dap_client_get_uplink_port_unsafe(dap_client_t * a_client)
return DAP_CLIENT_PVT(a_client)->uplink_port;
}
-/**
- * @brief dap_client_set_auth_cert
- * @param a_client
- * @param a_chain_net_name
- * @param a_option
- */
-void dap_client_set_auth_cert(dap_client_t *a_client, const char *a_chain_net_name)
-{
- const char *l_auth_hash_str = NULL;
-
- if(a_client == NULL || a_chain_net_name == NULL){
- log_it(L_ERROR,"Chain-net is NULL for dap_client_set_auth_cert");
- return;
- }
-
- char *l_path = dap_strdup_printf("network/%s", a_chain_net_name);
- if (!l_path) {
- log_it(L_ERROR, "Can't allocate memory: file: %s line: %d", __FILE__, __LINE__);
- return;
- }
-
- dap_config_t *l_cfg = dap_config_open(l_path);
- free(l_path);
- if (!l_cfg) {
- log_it(L_ERROR, "Can't allocate memory: file: %s line: %d", __FILE__, __LINE__);
- return;
- }
-
- dap_cert_t *l_cert = dap_cert_find_by_name(dap_config_get_item_str(l_cfg, "general", "auth_cert"));
- if (!l_cert) {
- dap_config_close(l_cfg);
- log_it(L_ERROR,"l_cert is NULL by dap_cert_find_by_name");
- return;
- }
- dap_client_set_auth_cert_unsafe(a_client, l_cert);
-
- //dap_cert_delete(l_cert);
- dap_config_close(l_cfg);
-}
-
void dap_client_set_auth_cert_unsafe(dap_client_t * a_client, dap_cert_t *a_cert)
{
if(a_client == NULL){
@@ -234,7 +194,7 @@ void dap_client_set_auth_cert_unsafe(dap_client_t * a_client, dap_cert_t *a_cert
void dap_client_delete_unsafe(dap_client_t * a_client)
{
if ( DAP_CLIENT_PVT(a_client)->refs_count ==0 ){
- dap_client_pvt_delete( DAP_CLIENT_PVT(a_client) );
+ dap_client_pvt_delete_unsafe( DAP_CLIENT_PVT(a_client) );
pthread_mutex_destroy(&a_client->mutex);
DAP_DEL_Z(a_client)
} else
@@ -280,7 +240,7 @@ static void s_go_stage_on_client_worker_unsafe(dap_worker_t * a_worker,void * a_
if (!l_client || l_client->_internal != l_client_pvt) {
log_it(L_WARNING,"Client is NULL or corrupted, why? Refs %u", l_client_pvt->refs_count);
if ( l_client_pvt->refs_count ==0 ){
- dap_client_pvt_delete( l_client_pvt );
+ dap_client_pvt_delete_unsafe(l_client_pvt);
} else
l_client_pvt->is_to_delete = true;
return;
diff --git a/dap-sdk/net/client/dap_client_pvt.c b/dap-sdk/net/client/dap_client_pvt.c
index 1c722b920415e1274260b59c5b5190f384bf0069..4dc04661e783517de391d5560a68120cfebae637 100644
--- a/dap-sdk/net/client/dap_client_pvt.c
+++ b/dap-sdk/net/client/dap_client_pvt.c
@@ -79,7 +79,7 @@
#define DAP_ENC_KS_KEY_ID_SIZE 33
#endif
-static int s_max_attempts = 5;
+static int s_max_attempts = 3;
static int s_timeout = 20;
static bool s_debug_more = false;
static time_t s_client_timeout_read_after_connect_seconds = 5;
@@ -124,10 +124,11 @@ static bool s_stream_timer_timeout_check(void * a_arg);
*/
int dap_client_pvt_init()
{
- s_max_attempts = dap_config_get_item_int32_default(g_config,"dap_client","max_tries",5);
- s_timeout = dap_config_get_item_int32_default(g_config,"dap_client","timeout",10);
- s_debug_more = dap_config_get_item_bool_default(g_config,"dap_client","debug_more",false);
- s_client_timeout_read_after_connect_seconds = (time_t) dap_config_get_item_uint32_default(g_config,"dap_client","timeout_read_after_connect",5);
+ s_max_attempts = dap_config_get_item_int32_default(g_config, "dap_client", "max_tries", s_max_attempts);
+ s_timeout = dap_config_get_item_int32_default(g_config, "dap_client", "timeout", s_timeout);
+ s_debug_more = dap_config_get_item_bool_default(g_config, "dap_client", "debug_more", false);
+ s_client_timeout_read_after_connect_seconds = (time_t) dap_config_get_item_uint32_default(g_config,
+ "dap_client","timeout_read_after_connect", s_client_timeout_read_after_connect_seconds);
return 0;
}
@@ -161,10 +162,52 @@ void dap_client_pvt_new(dap_client_pvt_t * a_client_pvt)
/**
- * @brief dap_client_pvt_delete
+ * @brief dap_client_set_auth_cert
+ * @param a_client
+ * @param a_chain_net_name
+ * @param a_option
+ */
+void dap_client_set_auth_cert(dap_client_t *a_client, const char *a_chain_net_name)
+{
+ const char *l_auth_hash_str = NULL;
+
+ if(a_client == NULL || a_chain_net_name == NULL){
+ log_it(L_ERROR,"Chain-net is NULL for dap_client_set_auth_cert");
+ return;
+ }
+
+ char *l_path = dap_strdup_printf("network/%s", a_chain_net_name);
+ if (!l_path) {
+ log_it(L_ERROR, "Can't allocate memory: file: %s line: %d", __FILE__, __LINE__);
+ return;
+ }
+
+ dap_config_t *l_cfg = dap_config_open(l_path);
+ free(l_path);
+ if (!l_cfg) {
+ log_it(L_ERROR, "Can't allocate memory: file: %s line: %d", __FILE__, __LINE__);
+ return;
+ }
+
+ dap_cert_t *l_cert = dap_cert_find_by_name(dap_config_get_item_str(l_cfg, "general", "auth_cert"));
+ if (!l_cert) {
+ dap_config_close(l_cfg);
+ log_it(L_ERROR,"l_cert is NULL by dap_cert_find_by_name");
+ return;
+ }
+ dap_client_set_auth_cert_unsafe(a_client, l_cert);
+
+ //dap_cert_delete(l_cert);
+ dap_config_close(l_cfg);
+}
+
+
+
+/**
+ * @brief dap_client_pvt_delete_unsafe
* @param a_client_pvt
*/
-void dap_client_pvt_delete(dap_client_pvt_t * a_client_pvt)
+void dap_client_pvt_delete_unsafe(dap_client_pvt_t * a_client_pvt)
{
assert(a_client_pvt);
diff --git a/dap-sdk/net/client/include/dap_client.h b/dap-sdk/net/client/include/dap_client.h
index 0173b8cc673cb8db251c47f18b0bf3f78b308cb0..8457e838b7cfd55a0c0ca6eabdce765d5d20e815 100644
--- a/dap-sdk/net/client/include/dap_client.h
+++ b/dap-sdk/net/client/include/dap_client.h
@@ -139,7 +139,6 @@ dap_stream_ch_t * dap_client_get_stream_ch_unsafe(dap_client_t * a_client, uint8
const char * dap_client_get_stream_id(dap_client_t * a_client);
void dap_client_set_active_channels_unsafe (dap_client_t * a_client, const char * a_active_channels);
void dap_client_set_auth_cert_unsafe(dap_client_t * a_client, dap_cert_t *a_cert);
-void dap_client_set_auth_cert(dap_client_t *a_client, const char *a_chain_net_name);
dap_client_stage_t dap_client_get_stage(dap_client_t * a_client);
dap_client_stage_status_t dap_client_get_stage_status(dap_client_t * a_client);
diff --git a/dap-sdk/net/client/include/dap_client_pvt.h b/dap-sdk/net/client/include/dap_client_pvt.h
index 5dc2f3f0e5e0514e06198bc365a7e9b8b65954ac..81af1d0618fc580d240688e23caef24267d39c4c 100644
--- a/dap-sdk/net/client/include/dap_client_pvt.h
+++ b/dap-sdk/net/client/include/dap_client_pvt.h
@@ -116,7 +116,7 @@ void dap_client_pvt_request_enc(dap_client_pvt_t * a_client_internal, const char
dap_client_callback_int_t a_error_proc);
void dap_client_pvt_new(dap_client_pvt_t * a_client_internal);
-void dap_client_pvt_delete(dap_client_pvt_t * a_client_pvt);
+void dap_client_pvt_delete_unsafe(dap_client_pvt_t * a_client_pvt);
int dap_client_pvt_hh_add_unsafe(dap_client_pvt_t* a_client_pvt);
int dap_client_pvt_hh_del_unsafe(dap_client_pvt_t *a_client_pvt);
diff --git a/dap-sdk/net/core/CMakeLists.txt b/dap-sdk/net/core/CMakeLists.txt
index 5ed51a7bfb0e11bfeeee142d2e78146cc2833d7a..ca3fe8666b0f24b9575ffa8e9454e9e720e8bcfd 100644
--- a/dap-sdk/net/core/CMakeLists.txt
+++ b/dap-sdk/net/core/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_server_core C)
set(CMAKE_C_STANDARD 11)
diff --git a/dap-sdk/net/core/dap_events.c b/dap-sdk/net/core/dap_events.c
index accb805fec84b4394ead6b5ee0aafeedf0b2ac5b..85637f01faeeab6a6db109ceb18869c5bddbc5c3 100644
--- a/dap-sdk/net/core/dap_events.c
+++ b/dap-sdk/net/core/dap_events.c
@@ -298,7 +298,7 @@ void dap_events_delete( dap_events_t *a_events )
void dap_events_remove_and_delete_socket_unsafe(dap_events_t *a_events, dap_events_socket_t *a_socket, bool a_preserve_inheritor)
{
(void) a_events;
- int l_sock = a_socket->socket;
+// int l_sock = a_socket->socket;
// if( a_socket->type == DESCRIPTOR_TYPE_TIMER)
// log_it(L_DEBUG,"Remove timer %d", l_sock);
diff --git a/dap-sdk/net/core/dap_events_socket.c b/dap-sdk/net/core/dap_events_socket.c
index 445ebd07c62fdc327a497d7e75ff86f8540c3451..ea25e2cf6f560de4ff2f17931302a26079ff1b9a 100644
--- a/dap-sdk/net/core/dap_events_socket.c
+++ b/dap-sdk/net/core/dap_events_socket.c
@@ -1791,11 +1791,10 @@ void dap_events_socket_remove_and_delete_unsafe( dap_events_socket_t *a_es, bool
//log_it( L_DEBUG, "es is going to be removed from the lists and free the memory (0x%016X)", a_es );
dap_events_socket_remove_from_worker_unsafe(a_es, a_es->worker);
- //log_it( L_DEBUG, "dap_events_socket wrapped around %d socket is removed", a_es->socket );
-
if( a_es->callbacks.delete_callback )
a_es->callbacks.delete_callback( a_es, NULL ); // Init internal structure
+ //log_it( L_DEBUG, "dap_events_socket wrapped around %d socket is removed", a_es->socket );
dap_events_socket_delete_unsafe(a_es, preserve_inheritor);
}
diff --git a/dap-sdk/net/core/dap_server.c b/dap-sdk/net/core/dap_server.c
index bdbccb4a76f3768e801786fdf9fde5d8bce1986e..792af686326c764b136b3fd0e88a86ab907bbb5c 100644
--- a/dap-sdk/net/core/dap_server.c
+++ b/dap-sdk/net/core/dap_server.c
@@ -292,7 +292,6 @@ static int s_server_run(dap_server_t * a_server, dap_events_socket_callbacks_t *
l_callbacks.error_callback = a_callbacks->error_callback;
}
-// if we have poll exclusive
#ifdef DAP_EVENTS_CAPS_EPOLL
for(size_t l_worker_id = 0; l_worker_id < dap_events_worker_get_count() ; l_worker_id++){
dap_worker_t *l_w = dap_events_worker_get(l_worker_id);
@@ -305,6 +304,7 @@ static int s_server_run(dap_server_t * a_server, dap_events_socket_callbacks_t *
// Prepare for multi thread listening
l_es->ev_base_flags = EPOLLIN;
#ifdef EPOLLEXCLUSIVE
+ // if we have poll exclusive
l_es->ev_base_flags |= EPOLLET | EPOLLEXCLUSIVE;
#endif
l_es->_inheritor = a_server;
diff --git a/dap-sdk/net/core/dap_timerfd.c b/dap-sdk/net/core/dap_timerfd.c
index 9b6ff27f9b9b649e6ed4916de6fe73cbab6dffb8..044dca1e62f523d2a7a3aa9fef59f8fd45be9e4d 100644
--- a/dap-sdk/net/core/dap_timerfd.c
+++ b/dap-sdk/net/core/dap_timerfd.c
@@ -305,7 +305,8 @@ static void s_es_callback_timer(struct dap_events_socket *a_event_sock)
* @param a_tfd
* @param a_callback
*/
-void dap_timerfd_delete(dap_timerfd_t *l_timerfd)
+void dap_timerfd_delete(dap_timerfd_t *a_timerfd)
{
- dap_events_socket_remove_and_delete_mt(l_timerfd->events_socket->worker, l_timerfd->esocket_uuid);
+ if (a_timerfd->events_socket->worker)
+ dap_events_socket_remove_and_delete_mt(a_timerfd->events_socket->worker, a_timerfd->esocket_uuid);
}
diff --git a/dap-sdk/net/core/dap_worker.c b/dap-sdk/net/core/dap_worker.c
index 9ae994fabc1ae7c7d2c4fe53a9c6e8cc6643864d..68c7bcc6e95066191c91fa8b08303d54755c4da8 100644
--- a/dap-sdk/net/core/dap_worker.c
+++ b/dap-sdk/net/core/dap_worker.c
@@ -202,7 +202,6 @@ void *dap_worker_thread(void *arg)
time_t l_cur_time = time( NULL);
for(size_t n = 0; n < l_sockets_max; n++) {
-
bool l_flag_hup, l_flag_rdhup, l_flag_read, l_flag_write, l_flag_error, l_flag_nval, l_flag_msg, l_flag_pri;
#ifdef DAP_EVENTS_CAPS_EPOLL
l_cur = (dap_events_socket_t *) l_epoll_events[n].data.ptr;
@@ -280,8 +279,8 @@ void *dap_worker_thread(void *arg)
#else
#error "Unimplemented fetch esocket after poll"
#endif
- if(!l_cur) {
- log_it(L_ERROR, "dap_events_socket NULL");
+ if(!l_cur || (l_cur->worker && l_cur->worker != l_worker)) {
+ log_it(L_WARNING, "dap_events_socket was destroyed earlier");
continue;
}
if(s_debug_reactor) {
@@ -356,7 +355,8 @@ void *dap_worker_thread(void *arg)
dap_events_socket_set_readable_unsafe(l_cur, false);
dap_events_socket_set_writable_unsafe(l_cur, false);
l_cur->buf_out_size = 0;
- l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
+ if (!l_cur->no_close)
+ l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
if(l_cur->callbacks.error_callback)
l_cur->callbacks.error_callback(l_cur, l_sock_err); // Call callback to process error event
}
@@ -527,7 +527,8 @@ void *dap_worker_thread(void *arg)
log_it(L_ERROR, "Some error occured in recv() function: %s", strerror(errno));
#endif
dap_events_socket_set_readable_unsafe(l_cur, false);
- l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
+ if (!l_cur->no_close)
+ l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
l_cur->buf_out_size = 0;
}
#ifndef DAP_NET_CLIENT_NO_SSL
@@ -536,7 +537,8 @@ void *dap_worker_thread(void *arg)
wolfSSL_ERR_error_string(l_errno, l_err_str);
log_it(L_ERROR, "Some error occured in SSL read(): %s (code %d)", l_err_str, l_errno);
dap_events_socket_set_readable_unsafe(l_cur, false);
- l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
+ if (!l_cur->no_close)
+ l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
l_cur->buf_out_size = 0;
}
#endif
@@ -654,7 +656,7 @@ void *dap_worker_thread(void *arg)
l_bytes_sent = send(l_cur->socket, (const char *)l_cur->buf_out,
l_cur->buf_out_size, MSG_DONTWAIT | MSG_NOSIGNAL);
#ifdef DAP_OS_WINDOWS
- dap_events_socket_set_writable_unsafe(l_cur,false);
+ //dap_events_socket_set_writable_unsafe(l_cur,false); // enabling this will break windows server replies
l_errno = WSAGetLastError();
#else
l_errno = errno;
@@ -752,7 +754,7 @@ void *dap_worker_thread(void *arg)
break;
case DESCRIPTOR_TYPE_PIPE:
case DESCRIPTOR_TYPE_FILE:
- l_bytes_sent = write(l_cur->socket, (char *) (l_cur->buf_out), l_cur->buf_out_size );
+ l_bytes_sent = write(l_cur->fd, (char *) (l_cur->buf_out), l_cur->buf_out_size );
l_errno = errno;
break;
default:
@@ -769,7 +771,8 @@ void *dap_worker_thread(void *arg)
{ // If we have non-blocking socket
log_it(L_ERROR, "Some error occured in send(): %s (code %d)", strerror(l_errno), l_errno);
#endif
- l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
+ if (!l_cur->no_close)
+ l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
l_cur->buf_out_size = 0;
}
#ifndef DAP_NET_CLIENT_NO_SSL
@@ -777,7 +780,8 @@ void *dap_worker_thread(void *arg)
char l_err_str[80];
wolfSSL_ERR_error_string(l_errno, l_err_str);
log_it(L_ERROR, "Some error occured in SSL write(): %s (code %d)", l_err_str, l_errno);
- l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
+ if (!l_cur->no_close)
+ l_cur->flags |= DAP_SOCK_SIGNAL_CLOSE;
l_cur->buf_out_size = 0;
}
#endif
@@ -801,7 +805,7 @@ void *dap_worker_thread(void *arg)
dap_events_socket_set_writable_unsafe(l_cur,true);
}
- if ((l_cur->flags & DAP_SOCK_SIGNAL_CLOSE) && !l_cur->no_close)
+ if (l_cur->flags & DAP_SOCK_SIGNAL_CLOSE)
{
if (l_cur->buf_out_size == 0) {
if(s_debug_reactor)
diff --git a/dap-sdk/net/server/CMakeLists.txt b/dap-sdk/net/server/CMakeLists.txt
index d2023893c59c26ed300b4f149efd06f0974cd9a4..2ad3a1a3f50afb0ce56181094e0348a0aa290fef 100644
--- a/dap-sdk/net/server/CMakeLists.txt
+++ b/dap-sdk/net/server/CMakeLists.txt
@@ -1,5 +1,5 @@
project(libdap-server C)
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
add_subdirectory(notify_server)
add_subdirectory(http_server)
diff --git a/dap-sdk/net/server/enc_server/CMakeLists.txt b/dap-sdk/net/server/enc_server/CMakeLists.txt
index 3191a15d5e3f4cbdea8c2eaee44546fc416994ab..4f95407a85ec0b43c836ac9f5da15bb12ae3fe64 100644
--- a/dap-sdk/net/server/enc_server/CMakeLists.txt
+++ b/dap-sdk/net/server/enc_server/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(dap_enc_server C)
file(GLOB DAP_ENC_SERVER_SRCS FILES *.c)
diff --git a/dap-sdk/net/server/http_server/CMakeLists.txt b/dap-sdk/net/server/http_server/CMakeLists.txt
index 656f8e66cfd03d9b5b471a7847b230ee44bfb7e7..16daa91a058b15877759d622e6f370b07616d6d2 100644
--- a/dap-sdk/net/server/http_server/CMakeLists.txt
+++ b/dap-sdk/net/server/http_server/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_http_server C)
include_directories(http_client/include)
diff --git a/dap-sdk/net/server/http_server/http_client/CMakeLists.txt b/dap-sdk/net/server/http_server/http_client/CMakeLists.txt
index b3633d72034eddd642958862c19b0c10d4bcd206..ed8a4b76399e4a95785c854234229703776398ee 100644
--- a/dap-sdk/net/server/http_server/http_client/CMakeLists.txt
+++ b/dap-sdk/net/server/http_server/http_client/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_http_client)
set(HTTP_SRCS FILES *.c)
diff --git a/dap-sdk/net/server/http_server/http_client/dap_http_client.c b/dap-sdk/net/server/http_server/http_client/dap_http_client.c
index 2a5597c09d8f2628d2c7ffc6b231126f8e64a822..b9c0f0ff39bc9f12a4b09d8c5bda6d3cc0009bfe 100644
--- a/dap-sdk/net/server/http_server/http_client/dap_http_client.c
+++ b/dap-sdk/net/server/http_server/http_client/dap_http_client.c
@@ -645,7 +645,7 @@ void dap_http_client_out_header_generate(dap_http_client_t *a_http_client)
}
if ( a_http_client->out_content_type[0] ) {
dap_http_header_add(&a_http_client->out_headers,"Content-Type",a_http_client->out_content_type);
- log_it(L_DEBUG,"output: Content-Type = '%s'",a_http_client->out_content_type);
+ log_it(L_DEBUG,"Output: Content-Type = '%s'",a_http_client->out_content_type);
}
if ( a_http_client->out_content_length ) {
dap_snprintf(buf,sizeof(buf),"%zu",a_http_client->out_content_length);
diff --git a/dap-sdk/net/server/json_rpc/CMakeLists.txt b/dap-sdk/net/server/json_rpc/CMakeLists.txt
index 08c7ec1ec22fc6f62854945635c00c2a74c9370f..30207dcaa5881382df12e9c164e4bea61e7d0771 100644
--- a/dap-sdk/net/server/json_rpc/CMakeLists.txt
+++ b/dap-sdk/net/server/json_rpc/CMakeLists.txt
@@ -1,5 +1,5 @@
project(dap_json_rpc C)
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
add_definitions ("-D_GNU_SOURCE")
add_definitions("-Dfpic")
diff --git a/dap-sdk/net/server/notify_server/CMakeLists.txt b/dap-sdk/net/server/notify_server/CMakeLists.txt
index c2e03f922786cfb86f5bde0721c090501ecd9e77..8390370099ff6c10b1d12bf7be69d16e16f23d3c 100644
--- a/dap-sdk/net/server/notify_server/CMakeLists.txt
+++ b/dap-sdk/net/server/notify_server/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(dap_notify_srv C)
file(GLOB DAP_NOTIFY_SRV_SRCS FILES src/*.c)
diff --git a/dap-sdk/net/server/test/CMakeLists.txt b/dap-sdk/net/server/test/CMakeLists.txt
index 54660c94ba0d8a450c5c9444a4242954736979bf..ac1dab4e7dd873bf8662f825bb29dda39022b7ed 100644
--- a/dap-sdk/net/server/test/CMakeLists.txt
+++ b/dap-sdk/net/server/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(test)
set(CMAKE_C_STANDARD 11)
diff --git a/dap-sdk/net/server/test/enc_server/CMakeLists.txt b/dap-sdk/net/server/test/enc_server/CMakeLists.txt
index 3fd0ab3c3e42ca9e767325b08b0b782648f20b46..2d4df9c5f8087be29cc5c877f22775ea2ac7b303 100644
--- a/dap-sdk/net/server/test/enc_server/CMakeLists.txt
+++ b/dap-sdk/net/server/test/enc_server/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(enc_server_test)
diff --git a/dap-sdk/net/server/test/http_server/CMakeLists.txt b/dap-sdk/net/server/test/http_server/CMakeLists.txt
index 82d08553ab850ce038e95606af9a5d61d9bb7a85..df544336d79148e82a7d817eee4e34c256153022 100644
--- a/dap-sdk/net/server/test/http_server/CMakeLists.txt
+++ b/dap-sdk/net/server/test/http_server/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project(http_server_test)
diff --git a/dap-sdk/net/stream/CMakeLists.txt b/dap-sdk/net/stream/CMakeLists.txt
index 87d7d736450b46cba9d91e5d5d05abb88cb4fdee..22df0e497b903e8e991ae897ca3cc48103d508e5 100644
--- a/dap-sdk/net/stream/CMakeLists.txt
+++ b/dap-sdk/net/stream/CMakeLists.txt
@@ -1,5 +1,5 @@
project(libdap-stream C)
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
add_subdirectory(session)
add_subdirectory(stream)
diff --git a/dap-sdk/net/stream/ch/CMakeLists.txt b/dap-sdk/net/stream/ch/CMakeLists.txt
index e3b535b8d1fbcabebff12e47f44e844e571afc5e..056a3cdd62dbda62f4748f41b493336157fd34f8 100644
--- a/dap-sdk/net/stream/ch/CMakeLists.txt
+++ b/dap-sdk/net/stream/ch/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_stream_ch)
file(GLOB DAP_STREAM_CH_SRCS *.c)
diff --git a/dap-sdk/net/stream/session/CMakeLists.txt b/dap-sdk/net/stream/session/CMakeLists.txt
index 2e294300da2e7b203c1403803eef390997cef1e8..15dac099b8e1c26f913f984343757ec3f9143b86 100644
--- a/dap-sdk/net/stream/session/CMakeLists.txt
+++ b/dap-sdk/net/stream/session/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_session)
file(GLOB SESSION_SRCS *.c)
diff --git a/dap-sdk/net/stream/stream/CMakeLists.txt b/dap-sdk/net/stream/stream/CMakeLists.txt
index 264d313f849dffb88781867be56710f669e8ba39..16fb98fc4e6b8f0e6e25053a63756b6cd19b418b 100755
--- a/dap-sdk/net/stream/stream/CMakeLists.txt
+++ b/dap-sdk/net/stream/stream/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_stream)
file(GLOB STREAM_SRCS *.c)
diff --git a/dap-sdk/net/stream/stream/dap_stream.c b/dap-sdk/net/stream/stream/dap_stream.c
index 9a33b5f97471092db8804bb33eec318f84927f9a..689c203b0a738d81c94a06ae416ab47204e14d22 100644
--- a/dap-sdk/net/stream/stream/dap_stream.c
+++ b/dap-sdk/net/stream/stream/dap_stream.c
@@ -820,7 +820,7 @@ static void s_stream_proc_pkt_in(dap_stream_t * a_stream)
memcpy(l_ret_pkt.sig, c_dap_stream_sig, sizeof(l_ret_pkt.sig));
dap_events_socket_write_unsafe(a_stream->esocket, &l_ret_pkt, sizeof(l_ret_pkt));
// Reset client keepalive timer
- if (a_stream->keepalive_timer) {
+ if (a_stream->keepalive_timer && a_stream->keepalive_timer->events_socket->worker) {
void *l_arg = a_stream->keepalive_timer->callback_arg;
dap_timerfd_delete(a_stream->keepalive_timer);
a_stream->keepalive_timer = dap_timerfd_start_on_worker(a_stream->stream_worker->worker,
diff --git a/dap-sdk/net/stream/stream/dap_stream_pkt.c b/dap-sdk/net/stream/stream/dap_stream_pkt.c
index d0b5efa8aafe23f248c1bdf10bdee81ef9cedffb..38d14061d3e072b87f5908a7f0596b20f4b059f1 100644
--- a/dap-sdk/net/stream/stream/dap_stream_pkt.c
+++ b/dap-sdk/net/stream/stream/dap_stream_pkt.c
@@ -76,7 +76,7 @@ dap_stream_pkt_t * dap_stream_pkt_detect(void * a_data, size_t data_size)
if(memcmp(sig_start,c_dap_stream_sig,sizeof(c_dap_stream_sig))==0){
ret = (dap_stream_pkt_t *)sig_start;
if (length_left < sizeof(dap_stream_ch_pkt_hdr_t)) {
- log_it(L_ERROR, "Too small packet size %zu", length_left);
+ //log_it(L_ERROR, "Too small packet size %zu", length_left); // it's not an error, just random case
ret = NULL;
break;
}
diff --git a/modules/app-cli/CMakeLists.txt b/modules/app-cli/CMakeLists.txt
index 1e8f2c8be518be56301457cab24adfb726fea8e7..26a2deb1bd0440d63b7993d176f644a4d7478fe6 100644
--- a/modules/app-cli/CMakeLists.txt
+++ b/modules/app-cli/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_app_cli)
file(GLOB DAP_APP_CLI_SRCS *.c)
diff --git a/modules/chain/CMakeLists.txt b/modules/chain/CMakeLists.txt
index fc43ed57b2c79b37f3089e46a481d739373c15c3..e6071d1e9ead2ab3f78edf0ac8756c90b1c4fdce 100644
--- a/modules/chain/CMakeLists.txt
+++ b/modules/chain/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain)
file(GLOB DAP_CHAIN_SRCS *.c)
diff --git a/modules/chain/btc_rpc/CMakeLists.txt b/modules/chain/btc_rpc/CMakeLists.txt
index 9e9ded64a179d2bda42ee9430c581d9fc0fc3ce0..930181f7283cee04960465242c2c5448d8ee00b7 100644
--- a/modules/chain/btc_rpc/CMakeLists.txt
+++ b/modules/chain/btc_rpc/CMakeLists.txt
@@ -1,5 +1,5 @@
project(dap_chain_btc_rpc C)
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
add_definitions ("-D_GNU_SOURCE")
add_definitions("-Dfpic")
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index c118458f8a59b37f6c30fd7fc04dca6443d8a6ae..6a979e113ae7617d00918448d84390a8731c7c17 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -209,11 +209,17 @@ void dap_chain_delete(dap_chain_t * a_chain)
* @param a_atom_size
* @return
*/
-dap_chain_atom_ptr_t dap_chain_get_atom_by_hash(dap_chain_t * a_chain, dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size, dap_chain_cell_id_t a_cell_id)
+dap_chain_atom_ptr_t dap_chain_get_atom_by_hash(dap_chain_t * a_chain, dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size)
{
- dap_chain_atom_iter_t * l_iter = a_chain->callback_atom_iter_create(a_chain, a_cell_id);
- dap_chain_atom_ptr_t l_ret = a_chain->callback_atom_find_by_hash(l_iter, a_atom_hash, a_atom_size);
- a_chain->callback_atom_iter_delete(l_iter);
+ dap_chain_atom_ptr_t l_ret = NULL;
+ dap_chain_cell_t *l_cell, *l_iter_tmp;
+ HASH_ITER(hh, a_chain->cells, l_cell, l_iter_tmp) {
+ dap_chain_atom_iter_t * l_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id);
+ l_ret = a_chain->callback_atom_find_by_hash(l_iter, a_atom_hash, a_atom_size);
+ a_chain->callback_atom_iter_delete(l_iter);
+ if (l_ret)
+ break;
+ }
return l_ret;
}
@@ -248,21 +254,12 @@ static dap_chain_type_t s_chain_type_from_str(const char *a_type_str)
if(!dap_strcmp(a_type_str, "token")) {
return CHAIN_TYPE_TOKEN;
}
- // if(!dap_strcmp(a_type_str, "token_256")) {
- // return CHAIN_TYPE_256_TOKEN;
- // }
if(!dap_strcmp(a_type_str, "emission")) {
return CHAIN_TYPE_EMISSION;
}
- // if(!dap_strcmp(a_type_str, "emission_256")) {
- // return CHAIN_TYPE_256_EMISSION;
- // }
if(!dap_strcmp(a_type_str, "transaction")) {
return CHAIN_TYPE_TX;
}
- // if(!dap_strcmp(a_type_str, "transaction_256")) {
- // return CHAIN_TYPE_256_TX;
- // }
if(!dap_strcmp(a_type_str, "ca")) {
return CHAIN_TYPE_CA;
}
@@ -280,23 +277,17 @@ static dap_chain_type_t s_chain_type_from_str(const char *a_type_str)
*/
static uint16_t s_datum_type_from_str(const char *a_type_str)
{
- // if(!dap_strcmp(a_type_str, "token")) { // old
- // return DAP_CHAIN_DATUM_TOKEN_DECL;
- // }
if(!dap_strcmp(a_type_str, "token")) {
- return DAP_CHAIN_DATUM_256_TOKEN_DECL;
+ return DAP_CHAIN_DATUM_TOKEN_DECL;
}
- // if(!dap_strcmp(a_type_str, "emission")) {
- // return DAP_CHAIN_DATUM_TOKEN_EMISSION;
- // }
if(!dap_strcmp(a_type_str, "emission")) {
- return DAP_CHAIN_DATUM_256_TOKEN_EMISSION;
+ return DAP_CHAIN_DATUM_TOKEN_EMISSION;
}
- // if(!dap_strcmp(a_type_str, "transaction")) {
- // return DAP_CHAIN_DATUM_TX;
- // }
if(!dap_strcmp(a_type_str, "transaction")) {
- return DAP_CHAIN_DATUM_256_TX;
+ return DAP_CHAIN_DATUM_TX;
+ }
+ if(!dap_strcmp(a_type_str, "ca")) {
+ return DAP_CHAIN_DATUM_CA;
}
if (!dap_strcmp(a_type_str, "signer")) {
return DAP_CHAIN_DATUM_SIGNER;
@@ -314,17 +305,13 @@ static uint16_t s_chain_type_convert(dap_chain_type_t a_type)
{
switch (a_type) {
case CHAIN_TYPE_TOKEN:
- // return DAP_CHAIN_DATUM_TOKEN_DECL;
- // case CHAIN_TYPE_256_TOKEN:
- return DAP_CHAIN_DATUM_256_TOKEN_DECL;
+ return DAP_CHAIN_DATUM_TOKEN_DECL;
case CHAIN_TYPE_EMISSION:
- // return DAP_CHAIN_DATUM_TOKEN_EMISSION;
- // case CHAIN_TYPE_256_EMISSION: // 256
- return DAP_CHAIN_DATUM_256_TOKEN_EMISSION;
+ return DAP_CHAIN_DATUM_TOKEN_EMISSION;
case CHAIN_TYPE_TX:
- // return DAP_CHAIN_DATUM_TX;
- // case CHAIN_TYPE_256_TX: // 256
- return DAP_CHAIN_DATUM_256_TX;
+ return DAP_CHAIN_DATUM_TX;
+ case CHAIN_TYPE_CA:
+ return DAP_CHAIN_DATUM_CA;
default:
return DAP_CHAIN_DATUM_CUSTOM;
}
@@ -586,10 +573,10 @@ void dap_chain_add_callback_notify(dap_chain_t * a_chain, dap_chain_callback_not
* @param a_atom_hash
* @return
*/
-bool dap_chain_get_atom_last_hash(dap_chain_t * a_chain, dap_hash_fast_t * a_atom_hash, dap_chain_cell_id_t a_cell_id)
+bool dap_chain_get_atom_last_hash(dap_chain_t *a_chain, dap_hash_fast_t *a_atom_hash, dap_chain_cell_id_t a_cel_id)
{
bool l_ret = false;
- dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_cell_id);
+ dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_cel_id);
dap_chain_atom_ptr_t * l_lasts_atom;
size_t l_lasts_atom_count=0;
size_t* l_lasts_atom_size =NULL;
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 5f99b6083339ac399c6f3eccff42a7a5f3a6c28e..fe9a950693dbd5072953f6b20c41eadbcee98a41 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -70,10 +70,7 @@ static pthread_rwlock_t s_verificators_rwlock;
#define MAX_OUT_ITEMS 10
typedef struct dap_chain_ledger_token_emission_item {
dap_chain_hash_fast_t datum_token_emission_hash;
- //union {
dap_chain_datum_token_emission_t *datum_token_emission;
- // dap_chain_datum_256_token_emission_t *datum_256_token_emission; // 256
- //};
size_t datum_token_emission_size;
UT_hash_handle hh;
} dap_chain_ledger_token_emission_item_t;
@@ -128,17 +125,10 @@ typedef struct dap_chain_ledger_tx_item {
} dap_chain_ledger_tx_item_t;
typedef struct dap_chain_ledger_tokenizer {
- // bool type_256;
- char token_ticker[10];
- uint64_t sum;
- UT_hash_handle hh;
-} dap_chain_ledger_tokenizer_t;
-
-typedef struct dap_chain_ledger_tokenizer_256 {
char token_ticker[10];
uint256_t sum;
UT_hash_handle hh;
-} dap_chain_ledger_tokenizer_256_t;
+} dap_chain_ledger_tokenizer_t;
typedef struct dap_chain_ledger_tx_bound {
dap_chain_hash_fast_t tx_prev_hash_fast;
@@ -149,12 +139,10 @@ typedef struct dap_chain_ledger_tx_bound {
} in;
union {
dap_chain_tx_out_t *tx_prev_out;
- dap_chain_tx_out_ext_t *tx_prev_out_ext;
- dap_chain_tx_out_cond_t *tx_prev_out_cond;
// 256
dap_chain_256_tx_out_t *tx_prev_out_256;
- dap_chain_256_tx_out_ext_t *tx_prev_out_ext_256;
- dap_chain_256_tx_out_cond_t *tx_prev_out_cond_256;
+ dap_chain_tx_out_ext_t *tx_prev_out_ext_256;
+ dap_chain_tx_out_cond_t *tx_prev_out_cond_256;
} out;
dap_chain_ledger_tx_item_t *item_out;
} dap_chain_ledger_tx_bound_t;
@@ -163,7 +151,6 @@ typedef struct dap_chain_ledger_tx_bound {
typedef struct dap_ledger_wallet_balance {
char *key;
char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
- //uint128_t balance;
uint256_t balance;
UT_hash_handle hh;
} dap_ledger_wallet_balance_t;
@@ -245,7 +232,7 @@ void dap_chain_ledger_deinit()
uint16_t l_net_count = 0;
dap_chain_net_t **l_net_list = dap_chain_net_list(&l_net_count);
for(uint16_t i =0; i < l_net_count; i++) {
- dap_chain_ledger_purge(l_net_list[i]->pub.ledger);
+ dap_chain_ledger_purge(l_net_list[i]->pub.ledger, true);
}
DAP_DELETE(l_net_list);
}
@@ -291,17 +278,13 @@ void dap_chain_ledger_handle_free(dap_ledger_t *a_ledger)
}
-
-/*static int compare_datum_items(const void * l_a, const void * l_b)
+void dap_chain_ledger_load_end(dap_ledger_t *a_ledger)
{
- const dap_chain_datum_t *l_item_a = (const dap_chain_datum_t*) l_a;
- const dap_chain_datum_t *l_item_b = (const dap_chain_datum_t*) l_b;
- if(l_item_a->header.ts_create == l_item_b->header.ts_create)
- return 0;
- if(l_item_a->header.ts_create < l_item_b->header.ts_create)
- return -1;
- return 1;
-}*/
+ PVT(a_ledger)->last_tx.found = true;
+ PVT(a_ledger)->last_thres_tx.found = true;
+ PVT(a_ledger)->last_emit.found = true;
+ PVT(a_ledger)->last_ticker.found = true;
+}
/**
@@ -310,7 +293,7 @@ void dap_chain_ledger_handle_free(dap_ledger_t *a_ledger)
* @param a_token
* @return
*/
-int dap_chain_ledger_token_decl_add_check(dap_ledger_t * a_ledger, dap_chain_datum_token_t *a_token)
+int dap_chain_ledger_token_decl_add_check(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token)
{
if ( !a_ledger){
if(s_debug_more)
@@ -318,9 +301,9 @@ int dap_chain_ledger_token_decl_add_check(dap_ledger_t * a_ledger, dap_chain_da
return -1;
}
- dap_chain_ledger_token_item_t * l_token_item;
+ dap_chain_ledger_token_item_t *l_token_item;
pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
- HASH_FIND_STR(PVT(a_ledger)->tokens,a_token->ticker,l_token_item);
+ HASH_FIND_STR(PVT(a_ledger)->tokens, a_token->ticker, l_token_item);
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
if ( l_token_item != NULL ){
log_it(L_WARNING,"Duplicate token declaration for ticker '%s' ", a_token->ticker);
@@ -356,17 +339,16 @@ int dap_chain_ledger_token_ticker_check(dap_ledger_t * a_ledger, const char *a_t
* @param a_token_size
* @return
*/
-int dap_chain_ledger_token_add(dap_ledger_t * a_ledger, dap_chain_datum_token_t *a_token, size_t a_token_size)
+int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token, size_t a_token_size)
{
if ( !a_ledger){
if(s_debug_more)
log_it(L_ERROR, "NULL ledger, can't add datum with token declaration!");
return -1;
}
-
dap_chain_ledger_token_item_t * l_token_item;
pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
- HASH_FIND_STR(PVT(a_ledger)->tokens,a_token->ticker,l_token_item);
+ HASH_FIND_STR(PVT(a_ledger)->tokens, a_token->ticker,l_token_item);
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
if (l_token_item) {
@@ -376,10 +358,10 @@ int dap_chain_ledger_token_add(dap_ledger_t * a_ledger, dap_chain_datum_token_t
}
l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
- dap_snprintf(l_token_item->ticker,sizeof (l_token_item->ticker),"%s",a_token->ticker);
+ dap_snprintf(l_token_item->ticker,sizeof (l_token_item->ticker), "%s", a_token->ticker);
pthread_rwlock_init(&l_token_item->token_emissions_rwlock,NULL);
l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
- memcpy(l_token_item->datum_token, a_token,a_token_size);
+ memcpy(l_token_item->datum_token, a_token, a_token_size);
pthread_rwlock_wrlock(&PVT(a_ledger)->tokens_rwlock);
HASH_ADD_STR(PVT(a_ledger)->tokens, ticker, l_token_item);
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
@@ -407,7 +389,7 @@ int dap_chain_ledger_token_add(dap_ledger_t * a_ledger, dap_chain_datum_token_t
}
if(s_debug_more)
log_it(L_NOTICE, "Simple token %s added (total_supply = %s total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE )",
- a_token->ticker, dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(a_token->header_private.total_supply_256)),
+ a_token->ticker, dap_chain_balance_to_coins(a_token->header_private.total_supply_256),
a_token->header_private.signs_valid, a_token->header_private.signs_total);
}
break;
@@ -455,7 +437,7 @@ int dap_chain_ledger_token_add(dap_ledger_t * a_ledger, dap_chain_datum_token_t
log_it(L_WARNING,"Unknown token declaration type 0x%04X", a_token->type );
}
// Proc emissions tresholds
- s_treshold_emissions_proc( a_ledger);
+ //s_treshold_emissions_proc( a_ledger); //TODO process thresholds only for no-consensus chains
return 0;
}
@@ -912,7 +894,7 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
return 0;
}
-int dap_chain_ledger_token_load(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token, size_t a_token_size)
+int dap_chain_ledger_token_load(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token, size_t a_token_size)
{
if (PVT(a_ledger)->last_ticker.found) {
return dap_chain_ledger_token_add(a_ledger, a_token, a_token_size);
@@ -950,7 +932,7 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger)
"\tAuth signs (valid/total) %zu/%zu\n"
"\tTotal emissions %u\n",
&l_token_item->ticker, l_type_str, l_token_item->flags,
- dap_chain_u256tostr(l_token_item->current_supply), dap_chain_u256tostr(l_token_item->total_supply),
+ dap_chain_balance_print(l_token_item->current_supply), dap_chain_balance_print(l_token_item->total_supply),
l_token_item->auth_signs_valid, l_token_item->auth_signs_total,
HASH_COUNT(l_token_item->token_emissions));
l_ret_list = dap_list_append(l_ret_list, l_item_str);
@@ -1037,7 +1019,6 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
size_t l_token_size = l_objs[i].value_len;
l_token_item->datum_token = dap_chain_datum_token_read(l_objs[i].value, &l_token_size);
pthread_rwlock_init(&l_token_item->token_emissions_rwlock, NULL);
-
// test tsd
// size_t signs_total = 0, signs_valid = 0, l_token_size_test = l_token_size - sizeof(dap_chain_datum_token_t) + sizeof(dap_chain_datum_token_old_t);
// dap_sign_t **sign = dap_chain_datum_token_simple_signs_parse( l_token_item->datum_token, l_token_size_test, &signs_total, &signs_valid);
@@ -1047,6 +1028,13 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
l_token_item->total_supply = GET_256_FROM_64(l_token_item->datum_token->header_private.total_supply);
} else if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE) {
l_token_item->total_supply = l_token_item->datum_token->header_private.total_supply_256;
+ if (l_token_item->auth_signs_total) {
+ l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,
+ sizeof(dap_chain_hash_fast_t) * l_token_item->auth_signs_total);
+ for (uint16_t k=0; k < l_token_item->auth_signs_total; k++) {
+ dap_sign_get_pkey_hash(l_token_item->auth_signs[k], &l_token_item->auth_signs_pkey_hash[k]);
+ }
+ }
}
HASH_ADD_STR(l_ledger_pvt->tokens, ticker, l_token_item);
if (i == l_objs_count - 1) {
@@ -1055,7 +1043,7 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
}
dap_chain_global_db_objs_delete(l_objs, l_objs_count);
DAP_DELETE(l_gdb_group);
- if (l_objs_count == 0) {
+ if (l_objs_count == 0 || l_ledger_pvt->last_ticker.key == NULL) {
l_ledger_pvt->last_ticker.found = true;
}
@@ -1089,7 +1077,7 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
}
dap_chain_global_db_objs_delete(l_objs, l_objs_count);
DAP_DELETE(l_gdb_group);
- if (l_objs_count == 0) {
+ if (l_objs_count == 0 || l_ledger_pvt->last_emit.hash == NULL) {
l_ledger_pvt->last_emit.found = true;
}
@@ -1104,12 +1092,12 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
memcpy(&l_tx_item->cache_data, l_objs[i].value, sizeof(l_tx_item->cache_data));
HASH_ADD(hh, l_ledger_pvt->ledger_items, tx_hash_fast, sizeof(dap_chain_hash_fast_t), l_tx_item);
if (i == l_objs_count - 1) {
- PVT(a_ledger)->last_tx.hash = &l_tx_item->tx_hash_fast;
+ l_ledger_pvt->last_tx.hash = &l_tx_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) {
+ if (l_objs_count == 0 || l_ledger_pvt->last_tx.hash == NULL) {
l_ledger_pvt->last_tx.found = true;
}
@@ -1123,12 +1111,12 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
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);
if (i == l_objs_count - 1) {
- PVT(a_ledger)->last_thres_tx.hash = &l_tx_item->tx_hash_fast;
+ l_ledger_pvt->last_thres_tx.hash = &l_tx_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) {
+ if (l_objs_count == 0 || l_ledger_pvt->last_thres_tx.hash == NULL) {
l_ledger_pvt->last_thres_tx.found = true;
}
@@ -1146,9 +1134,8 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
strcpy(l_balance_item->token_ticker, l_ptr);
}
if ( l_v0_size == l_objs[i].value_len ) { // old data
- l_balance_item->balance = uint256_0;
l_balance_item->balance.lo = *(uint128_t *)l_objs[i].value;
- } else {
+ } else {
l_balance_item->balance = *(uint256_t *)l_objs[i].value;
}
HASH_ADD_KEYPTR(hh, l_ledger_pvt->balance_accounts, l_balance_item->key,
@@ -1188,7 +1175,7 @@ dap_ledger_t* dap_chain_ledger_create(uint16_t a_check_flags, char *a_net_name)
int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size)
{
- int ret = 0;
+ int l_ret = 0;
dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
const char * c_token_ticker = ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.ticker;
@@ -1212,84 +1199,79 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
pthread_rwlock_unlock(l_token_item ? &l_token_item->token_emissions_rwlock
: &l_ledger_priv->treshold_emissions_rwlock);
if(l_token_emission_item ) {
- if(s_debug_more)
+ if(s_debug_more) {
if ( l_token_emission_item->datum_token_emission->hdr.version == 1 ) //&& l_token_emission_item->datum_token_emission->hdr.type_256 )
log_it(L_ERROR, "Can't add token emission datum of %s %s ( %s ): already present in cache",
- dap_chain_u256tostr(l_token_emission_item->datum_token_emission->hdr.value_256), c_token_ticker, l_hash_str);
+ dap_chain_balance_print(l_token_emission_item->datum_token_emission->hdr.value_256), c_token_ticker, l_hash_str);
else
log_it(L_ERROR, "Can't add token emission datum of %"DAP_UINT64_FORMAT_U" %s ( %s ): already present in cache",
l_token_emission_item->datum_token_emission->hdr.value, c_token_ticker, l_hash_str);
- ret = -1;
+ }
+ l_ret = -1;
}else if ( (! l_token_item) && ( l_threshold_emissions_count >= s_treshold_emissions_max)) {
if(s_debug_more)
log_it(L_WARNING,"Treshold for emissions is overfulled (%zu max)",
s_treshold_emissions_max);
- ret = -2;
- }else{ // Chech emission correctness
- size_t l_emission_size = a_token_emission_size;
- dap_chain_datum_token_emission_t *l_emission = dap_chain_datum_emission_read(a_token_emission, &l_emission_size);
- switch (l_emission->hdr.type){
- // case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH:
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:{
- dap_chain_ledger_token_item_t *l_token_item=NULL;
- pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
- HASH_FIND_STR(PVT(a_ledger)->tokens, l_emission->hdr.ticker, l_token_item);
- pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
- if (l_token_item){
- assert(l_token_item->datum_token);
- if( PVT(a_ledger)->net->pub.token_emission_signs_verify ){
- dap_sign_t * l_sign =(dap_sign_t*) l_emission->data.type_auth.signs;
- size_t l_offset= (byte_t*)l_emission - (byte_t*) l_sign;
- uint16_t l_aproves = 0, l_aproves_valid = l_token_item->auth_signs_valid;
-
- for (uint16_t i=0; i <l_emission->data.type_auth.signs_count && l_offset < l_emission_size; i++){
- size_t l_sign_size = dap_sign_get_size(l_sign);
- l_sign = (dap_sign_t*) ((byte_t*) l_sign + l_sign_size);
- if (UINT16_MAX-l_offset> l_sign_size ){
- dap_chain_hash_fast_t l_sign_pkey_hash;
- dap_sign_get_pkey_hash(l_sign,&l_sign_pkey_hash);
- // Find pkey in auth hashes
- for(uint16_t k=0; k< l_token_item->auth_signs_total; k++ ){
- if ( dap_hash_fast_compare(&l_sign_pkey_hash, &l_token_item->auth_signs_pkey_hash[k])) {
- // Verify if its token emission header signed
- if (!dap_sign_verify_size(l_sign, l_emission_size)) {
- break;
- }
- if (dap_sign_verify(l_sign, &l_emission->hdr, sizeof(l_emission))) {
- l_aproves++;
- break;
- }
- }
+ l_ret = -2;
+ }
+ DAP_DELETE(l_hash_str);
+ if (l_ret || !PVT(a_ledger)->check_token_emission)
+ return l_ret;
+ // Check emission correctness
+ size_t l_emission_size = a_token_emission_size;
+ dap_chain_datum_token_emission_t *l_emission = dap_chain_datum_emission_read(a_token_emission, &l_emission_size);
+ switch (l_emission->hdr.type){
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:{
+ dap_chain_ledger_token_item_t *l_token_item=NULL;
+ pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
+ HASH_FIND_STR(PVT(a_ledger)->tokens, l_emission->hdr.ticker, l_token_item);
+ pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
+ if (l_token_item){
+ assert(l_token_item->datum_token);
+ dap_sign_t *l_sign = (dap_sign_t *)l_emission->data.type_auth.signs;
+ size_t l_offset = (byte_t *)l_sign - (byte_t *)l_emission;
+ uint16_t l_aproves = 0, l_aproves_valid = l_token_item->auth_signs_valid;
+ for (uint16_t i = 0; i < l_emission->data.type_auth.signs_count && l_offset < l_emission_size; i++) {
+ if (dap_sign_verify_size(l_sign, l_emission_size - l_offset)) {
+ dap_chain_hash_fast_t l_sign_pkey_hash;
+ dap_sign_get_pkey_hash(l_sign, &l_sign_pkey_hash);
+ // Find pkey in auth hashes
+ for (uint16_t k=0; k< l_token_item->auth_signs_total; k++) {
+ if (dap_hash_fast_compare(&l_sign_pkey_hash, &l_token_item->auth_signs_pkey_hash[k])) {
+ // Verify if its token emission header signed
+ if (dap_sign_verify(l_sign, &l_emission->hdr, sizeof(l_emission->hdr)) == 1) {
+ l_aproves++;
+ break;
}
- l_offset+=l_sign_size;
- }else
- l_offset = UINT16_MAX;
- }
-
- if (l_aproves < l_aproves_valid ){
- if(s_debug_more)
- if ( l_emission->hdr.version == 1 ) // && l_emission->hdr.type_256 ) // 256
- log_it(L_WARNING, "Emission of %s datoshi of %s:%s is wrong: only %u valid aproves when %u need",
- dap_chain_u256tostr(l_emission->hdr.value_256), a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
- else
- log_it(L_WARNING, "Emission of %"DAP_UINT64_FORMAT_U" datoshi of %s:%s is wrong: only %u valid aproves when %u need",
- l_emission->hdr.value, a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
- ret = -1;
+ }
}
+ size_t l_sign_size = dap_sign_get_size(l_sign);
+ l_offset += l_sign_size;
+ l_sign = (dap_sign_t *)((byte_t *)l_emission + l_offset);
+ } else
+ break;
+ }
+ if (l_aproves < l_aproves_valid ){
+ if(s_debug_more) {
+ if ( l_emission->hdr.version == 2 ) // 256
+ log_it(L_WARNING, "Emission of %s datoshi of %s:%s is wrong: only %u valid aproves when %u need",
+ dap_chain_balance_print(l_emission->hdr.value_256), a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
+ else
+ log_it(L_WARNING, "Emission of %"DAP_UINT64_FORMAT_U" datoshi of %s:%s is wrong: only %u valid aproves when %u need",
+ l_emission->hdr.value, a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
}
- }else{
- if(s_debug_more)
- log_it(L_WARNING,"Can't find token declaration %s:%s thats pointed in token emission datum", a_ledger->net_name, l_emission->hdr.ticker);
- ret = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS;
+ l_ret = -3;
}
- }break;
- default:{}
- }
- DAP_DELETE(l_emission);
+ }else{
+ if(s_debug_more)
+ log_it(L_WARNING,"Can't find token declaration %s:%s thats pointed in token emission datum", a_ledger->net_name, l_emission->hdr.ticker);
+ l_ret = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_TOKEN;
+ }
+ }break;
+ default:{}
}
- DAP_DELETE(l_hash_str);
-
- return ret;
+ DAP_DELETE(l_emission);
+ return l_ret;
}
/**
@@ -1351,13 +1333,13 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
}
DAP_DELETE(l_gdb_group);
char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_emission_item->datum_token_emission->hdr.address) );
- if(s_debug_more)
+ if(s_debug_more) {
if ( l_token_emission_item->datum_token_emission->hdr.version == 1 ) // && l_token_emission_item->datum_token_emission->hdr.type_256 )
log_it(L_NOTICE, "Added token emission datum to %s: type=%s value=%s token=%s to_addr=%s ",
l_token_item?"emissions cache":"emissions treshold",
c_dap_chain_datum_token_emission_type_str[ l_token_emission_item->datum_token_emission->hdr.type ] ,
dap_chain_balance_to_coins(
- dap_chain_uint128_from_uint256(l_token_emission_item->datum_token_emission->hdr.value_256)
+ l_token_emission_item->datum_token_emission->hdr.value_256
), c_token_ticker,
l_token_emission_address_str);
else
@@ -1366,6 +1348,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
c_dap_chain_datum_token_emission_type_str[ l_token_emission_item->datum_token_emission->hdr.type ] ,
dap_chain_datoshi_to_coins(l_token_emission_item->datum_token_emission->hdr.value), c_token_ticker,
l_token_emission_address_str);
+ }
DAP_DELETE(l_token_emission_address_str);
}else{
if(s_debug_more)
@@ -1375,13 +1358,14 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
}
} else {
if (l_token_item) {
- if(s_debug_more)
+ if(s_debug_more) {
if ( ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.version == 1 ) // && ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.type_256 ) // 256
log_it(L_ERROR, "Duplicate token emission datum of %s %s ( %s )",
- dap_chain_u256tostr(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value_256), c_token_ticker, l_hash_str);
+ dap_chain_balance_print(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value_256), c_token_ticker, l_hash_str);
else
log_it(L_ERROR, "Duplicate token emission datum of %"DAP_UINT64_FORMAT_U" %s ( %s )",
((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value, c_token_ticker, l_hash_str);
+ }
}
ret = -1;
}
@@ -1412,7 +1396,6 @@ int dap_chain_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token
dap_chain_datum_token_emission_t * dap_chain_ledger_token_emission_find(dap_ledger_t *a_ledger,
const char *a_token_ticker, const dap_chain_hash_fast_t *a_token_emission_hash)
{
-
dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
dap_chain_datum_token_emission_t * l_token_emission = NULL;
dap_chain_ledger_token_item_t * l_token_item = NULL;
@@ -1678,10 +1661,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
// sum of values in 'out' items from the previous transactions
dap_chain_ledger_tokenizer_t *l_values_from_prev_tx = NULL, *l_values_from_cur_tx = NULL,
*l_value_cur = NULL, *l_tmp = NULL, *l_res = NULL;
-
- dap_chain_ledger_tokenizer_256_t *l_values_from_prev_tx_256 = NULL, *l_values_from_cur_tx_256 = NULL,
- *l_value_cur_256 = NULL, *l_tmp_256 = NULL, *l_res_256 = NULL;
-
char *l_token = NULL;
dap_chain_ledger_token_item_t * l_token_item = NULL;
dap_chain_hash_fast_t *l_emission_hash;
@@ -1720,9 +1699,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
dap_chain_tx_in_cond_t *l_tx_in_cond;
dap_chain_hash_fast_t l_tx_prev_hash={0};
uint8_t l_cond_type = *(uint8_t *)l_list_tmp->data;
-
- bool l_is_type_256 = false; // 256 type
-
// one of the previous transaction
if (l_cond_type == TX_ITEM_TYPE_IN) {
l_tx_in = (dap_chain_tx_in_t *)l_list_tmp->data;
@@ -1756,17 +1732,12 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_is_first_transaction = true;
if (!l_token) {
dap_chain_tx_token_t *l_tx_token = (dap_chain_tx_token_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_TOKEN, NULL);
- dap_chain_tx_token_t *l_tx_token_256 = (dap_chain_tx_token_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_256_TOKEN, NULL);
- if (l_tx_token) { // TX_ITEM_TYPE_TOKEN
- l_token = l_tx_token->header.ticker;
- l_emission_hash = &l_tx_token->header.token_emission_hash;
- } else if (l_tx_token_256) { // TX_ITEM_TYPE_256_TOKEN
- l_token = l_tx_token_256->header.ticker;
- l_emission_hash = &l_tx_token_256->header.token_emission_hash;
- } else {
+ if (!l_tx_token) {
l_err_num = -4;
break;
}
+ l_token = l_tx_token->header.ticker;
+ l_emission_hash = &l_tx_token->header.token_emission_hash;
}
DAP_DELETE(bound_item);
continue;
@@ -1807,9 +1778,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
break;
}
- uint64_t l_value;
- uint256_t l_value_256 = uint256_0;
-
+ uint256_t l_value;
// Get list of all 'out' items from previous transaction
dap_list_t *l_list_prev_out = dap_chain_datum_tx_items_get(l_tx_prev, TX_ITEM_TYPE_OUT_ALL, NULL);
// Get one 'out' item in previous transaction bound with current 'in' item
@@ -1821,36 +1790,24 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
if (l_cond_type == TX_ITEM_TYPE_IN) {
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_tx_prev_out;
-
- // if ( l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT ) {
- // bound_item->out.tx_prev_out = l_tx_prev_out;
- // memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out->addr,sizeof (bound_item->out.tx_prev_out->addr));
- // } else {
- // bound_item->out.tx_prev_out_ext = l_tx_prev_out;
- // memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_ext->addr,sizeof (bound_item->out.tx_prev_out_ext->addr));
- // }
-
- if ( l_type == TX_ITEM_TYPE_OUT ) {
- l_is_type_256 = false;
+ switch (l_type) {
+ case TX_ITEM_TYPE_OUT:
bound_item->out.tx_prev_out = l_tx_prev_out;
memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out->addr,sizeof (bound_item->out.tx_prev_out->addr));
- } else if ( l_type == TX_ITEM_TYPE_256_OUT ) { // 256
- l_is_type_256 = true;
+ break;
+ case TX_ITEM_TYPE_OUT_256: // 256
bound_item->out.tx_prev_out_256 = l_tx_prev_out;
memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_256->addr,sizeof (bound_item->out.tx_prev_out_256->addr));
- } else if (l_type == TX_ITEM_TYPE_OUT_EXT ) {
- l_is_type_256 = false;
- bound_item->out.tx_prev_out_ext = l_tx_prev_out;
- memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_ext->addr,sizeof (bound_item->out.tx_prev_out_ext->addr));
- } else if ( l_type == TX_ITEM_TYPE_256_OUT_EXT ) { // 256
- l_is_type_256 = true;
+ break;
+ case TX_ITEM_TYPE_OUT_EXT: // 256
bound_item->out.tx_prev_out_ext_256 = l_tx_prev_out;
memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_ext_256->addr,sizeof (bound_item->out.tx_prev_out_ext_256->addr));
- } else {
- l_err_num = -8;
break;
+ default:
+ l_err_num = -8;
}
-
+ if (l_err_num)
+ break;
// calculate hash of public key in current transaction
dap_chain_hash_fast_t l_hash_pkey;
@@ -1867,20 +1824,14 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
dap_hash_fast(l_pkey_ser, l_pkey_ser_size, &l_hash_pkey);
// hash of public key in 'out' item of previous transaction
- // uint8_t *l_prev_out_addr_key = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ?
- // bound_item->out.tx_prev_out->addr.data.key :
- // bound_item->out.tx_prev_out_ext->addr.data.key;
-
uint8_t *l_prev_out_addr_key = NULL;
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT:
+ case TX_ITEM_TYPE_OUT_256:
l_prev_out_addr_key = bound_item->out.tx_prev_out_256->addr.data.key; break;
case TX_ITEM_TYPE_OUT:
l_prev_out_addr_key = bound_item->out.tx_prev_out->addr.data.key; break;
- case TX_ITEM_TYPE_256_OUT_EXT:
- l_prev_out_addr_key = bound_item->out.tx_prev_out_ext_256->addr.data.key; break;
case TX_ITEM_TYPE_OUT_EXT:
- l_prev_out_addr_key = bound_item->out.tx_prev_out_ext->addr.data.key; break;
+ l_prev_out_addr_key = bound_item->out.tx_prev_out_ext_256->addr.data.key; break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
@@ -1894,30 +1845,24 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT: // 256
- l_value_256 = bound_item->out.tx_prev_out_256->header.value; break;
+ case TX_ITEM_TYPE_OUT_256: // 256
+ l_value = bound_item->out.tx_prev_out_256->header.value; break;
case TX_ITEM_TYPE_OUT:
- l_value = bound_item->out.tx_prev_out->header.value; break;
- case TX_ITEM_TYPE_256_OUT_EXT: // 256
- l_value_256 = bound_item->out.tx_prev_out_ext_256->header.value;
- l_token = bound_item->out.tx_prev_out_ext->token;
- break;
- case TX_ITEM_TYPE_OUT_EXT:
- l_value = bound_item->out.tx_prev_out_ext->header.value;
- l_token = bound_item->out.tx_prev_out_ext->token;
- break;
+ l_value = dap_chain_uint256_from(bound_item->out.tx_prev_out->header.value); break;
+ case TX_ITEM_TYPE_OUT_EXT: // 256
+ l_value = bound_item->out.tx_prev_out_ext_256->header.value;
+ l_token = bound_item->out.tx_prev_out_ext_256->token;
+ break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
}
-
} else { // TX_ITEM_TYPE_IN_COND
- dap_chain_tx_item_type_t l_type = *(uint8_t *)l_tx_prev_out;
- if( l_type != TX_ITEM_TYPE_OUT_COND && l_type != TX_ITEM_TYPE_256_OUT_COND) {
+ if(*(uint8_t *)l_tx_prev_out != TX_ITEM_TYPE_OUT_256_COND) {
l_err_num = -8;
break;
}
- if (!l_token_item){
+ if (! l_token_item){
l_err_num = -16;
log_it(L_ERROR,"Can't find token item for conditioned tx out");
break;
@@ -1932,20 +1877,8 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
size_t l_pkey_ser_size = 0;
const uint8_t *l_pkey_ser = dap_sign_get_pkey(l_sign, &l_pkey_ser_size);
-
dap_chain_tx_out_cond_t *l_tx_prev_out_cond = NULL;
- dap_chain_256_tx_out_cond_t *l_tx_prev_out_cond_256 = NULL; // 256
-
- if ( l_type == TX_ITEM_TYPE_256_OUT_COND ) { // 256
- l_is_type_256 = true;
- l_tx_prev_out_cond_256 = (dap_chain_256_tx_out_cond_t *)l_tx_prev_out;
- } else {
- l_is_type_256 = false;
- l_tx_prev_out_cond = (dap_chain_tx_out_cond_t *)l_tx_prev_out;
- }
-
- // dap_chain_tx_out_cond_t *l_tx_prev_out_cond = (dap_chain_tx_out_cond_t *)l_tx_prev_out;
- // l_is_type_256 = l_type == TX_ITEM_TYPE_256_OUT_COND ? true : false;
+ l_tx_prev_out_cond = (dap_chain_tx_out_cond_t *)l_tx_prev_out;
bool l_owner = false;
if (l_pkey_ser_size == l_prev_pkey_ser_size &&
@@ -1954,16 +1887,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
// 5b. Call verificator for conditional output
dap_chain_ledger_verificator_t *l_verificator;
- // int l_tmp = (int)l_tx_prev_out_cond->header.subtype;
- // int l_tmp;
- // if ( l_type == TX_ITEM_TYPE_256_OUT_COND ) { // 256
- // l_tmp = (int)l_tx_prev_out_cond_256->header.subtype;
- // } else {
- // l_tmp = (int)l_tx_prev_out_cond->header.subtype;
- // }
-
- int l_tmp = ( l_type == TX_ITEM_TYPE_256_OUT_COND ) ?
- (int)l_tx_prev_out_cond_256->header.subtype : (int)l_tx_prev_out_cond->header.subtype;
+ int l_tmp = l_tx_prev_out_cond->header.subtype;
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
@@ -1978,15 +1902,9 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_err_num = -14;
break;
}
-
- // bound_item->out.tx_prev_out_cond = l_tx_prev_out_cond;
- if ( l_type == TX_ITEM_TYPE_256_OUT_COND ) { // 256
- bound_item->out.tx_prev_out_cond_256 = l_tx_prev_out_cond;
- l_value_256 = l_tx_prev_out_cond_256->header.value;
- } else {
- bound_item->out.tx_prev_out_cond = l_tx_prev_out_cond;
- l_value = l_tx_prev_out_cond->header.value;
- }
+ // calculate sum of values from previous transactions
+ bound_item->out.tx_prev_out_cond_256 = l_tx_prev_out_cond;
+ l_value = l_tx_prev_out_cond->header.value;
l_token = NULL;
}
if (!l_token || !*l_token) {
@@ -2008,7 +1926,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
l_err_num = -15;
break;
}
-
// Check permissions
if ( (l_token_item->flags & DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED ) || // If all is blocked - check if we're
(l_token_item->flags & DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN) ){ // in white list
@@ -2036,43 +1953,18 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
}
- // HASH_FIND_STR(l_values_from_prev_tx, l_token, l_value_cur);
- // if (!l_value_cur) {
- // l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
- // strcpy(l_value_cur->token_ticker, l_token);
- // HASH_ADD_STR(l_values_from_prev_tx, token_ticker, l_value_cur);
-
- // if ( l_is_type_256 ) { // 256
- // l_value_cur->type_256 = true;
- // SUM_256_256(l_value_cur->sum_256, l_value_256, &l_value_cur->sum_256);
- // }else {
- // l_value_cur->type_256 = false;
- // l_value_cur->sum += l_value;
- // }
- // }
-
- if ( l_is_type_256 ) { // 256
- HASH_FIND_STR(l_values_from_prev_tx_256, l_token, l_value_cur_256);
- if (!l_value_cur_256) {
- l_value_cur_256 = DAP_NEW_Z(dap_chain_ledger_tokenizer_256_t);
- strcpy(l_value_cur_256->token_ticker, l_token);
- HASH_ADD_STR(l_values_from_prev_tx_256, token_ticker, l_value_cur_256);
- }
- SUM_256_256(l_value_cur_256->sum, l_value_256, &l_value_cur_256->sum);
-
- } else {
- HASH_FIND_STR(l_values_from_prev_tx, l_token, l_value_cur);
- if (!l_value_cur) {
- l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
- strcpy(l_value_cur->token_ticker, l_token);
- HASH_ADD_STR(l_values_from_prev_tx, token_ticker, l_value_cur);
- }
- // calculate sum of values from previous transactions per each token
- l_value_cur->sum += l_value;
+ HASH_FIND_STR(l_values_from_prev_tx, l_token, l_value_cur);
+ if (!l_value_cur) {
+ l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
+ strcpy(l_value_cur->token_ticker, l_token);
+ HASH_ADD_STR(l_values_from_prev_tx, token_ticker, l_value_cur);
}
+ // calculate sum of values from previous transactions per each token
+ SUM_256_256(l_value_cur->sum, l_value, &l_value_cur->sum);
l_list_bound_items = dap_list_append(l_list_bound_items, bound_item);
}
+
if (l_list_in)
dap_list_free(l_list_in);
@@ -2083,69 +1975,54 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
DAP_DELETE(l_value_cur);
}
- HASH_ITER(hh, l_values_from_prev_tx_256, l_value_cur_256, l_tmp_256) {
- DAP_DELETE(l_value_cur_256);
- }
return l_err_num;
}
// 6. Compare sum of values in 'out' items in the current transaction and in the previous transactions
// Calculate the sum of values in 'out' items from the current transaction
bool l_multichannel = false;
- if (HASH_COUNT(l_values_from_prev_tx) > 1){
+ if (HASH_COUNT(l_values_from_prev_tx) > 1) {
l_multichannel = true;
} else {
l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
if(l_token)
strcpy(l_value_cur->token_ticker, l_token);
HASH_ADD_STR(l_values_from_cur_tx, token_ticker, l_value_cur);
-
- // 256
- l_value_cur_256 = DAP_NEW_Z(dap_chain_ledger_tokenizer_256_t);
- if(l_token)
- strcpy(l_value_cur_256->token_ticker, l_token);
- HASH_ADD_STR(l_values_from_cur_tx_256, token_ticker, l_value_cur_256);
}
-
dap_list_t *l_list_tx_out = NULL;
bool emission_flag = !l_is_first_transaction || (l_is_first_transaction && l_ledger_priv->check_token_emission);
// find 'out' items
dap_list_t *l_list_out = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
- uint64_t l_value=0;
- uint256_t l_value_256=uint256_0;
+ uint256_t l_value = {};
for (l_list_tmp = l_list_out; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp)) {
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_list_tmp->data;
dap_chain_addr_t l_tx_out_to={0};
- bool l_is_type_256 = false;
-
- if (l_type == TX_ITEM_TYPE_OUT) {
- l_is_type_256 = false;
+ switch (l_type) {
+ case TX_ITEM_TYPE_OUT: {
dap_chain_tx_out_t *l_tx_out = (dap_chain_tx_out_t *)l_list_tmp->data;
if (l_multichannel) { // token ticker is mandatory for multichannel transactions
l_err_num = -16;
break;
}
if (emission_flag) {
- l_value = l_tx_out->header.value;
+ l_value = dap_chain_uint256_from(l_tx_out->header.value);
}
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
-
- } else if (l_type == TX_ITEM_TYPE_256_OUT) { // 256
- l_is_type_256 = true;
+ } break;
+ case TX_ITEM_TYPE_OUT_256: { // 256
dap_chain_256_tx_out_t *l_tx_out = (dap_chain_256_tx_out_t *)l_list_tmp->data;
if (l_multichannel) { // token ticker is mandatory for multichannel transactions
l_err_num = -16;
break;
}
if (emission_flag) {
- l_value_256 = l_tx_out->header.value;
+ l_value = l_tx_out->header.value;
}
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
-
- } else if (l_type == TX_ITEM_TYPE_OUT_EXT) {
- l_is_type_256 = false;
+ } break;
+ case TX_ITEM_TYPE_OUT_EXT: { // 256
dap_chain_tx_out_ext_t *l_tx_out = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
if (!l_multichannel) { // token ticker is depricated for single-channel transactions
l_err_num = -16;
@@ -2157,23 +2034,8 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
-
- } else if (l_type == TX_ITEM_TYPE_256_OUT_EXT) { // 256
- l_is_type_256 = true;
- dap_chain_256_tx_out_ext_t *l_tx_out = (dap_chain_256_tx_out_ext_t *)l_list_tmp->data;
- if (!l_multichannel) { // token ticker is depricated for single-channel transactions
- l_err_num = -16;
- break;
- }
- if (emission_flag) {
- l_value_256 = l_tx_out->header.value;
- l_token = l_tx_out->token;
- }
- memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
- l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
-
- } else if (l_type == TX_ITEM_TYPE_OUT_COND) {
- l_is_type_256 = false;
+ } break;
+ case TX_ITEM_TYPE_OUT_256_COND: {
dap_chain_tx_out_cond_t *l_tx_out = (dap_chain_tx_out_cond_t *)l_list_tmp->data;
if (emission_flag) {
l_value = l_tx_out->header.value;
@@ -2184,42 +2046,18 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
break;
}
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
-
- } else if (l_type == TX_ITEM_TYPE_256_OUT_COND) { // 256
- l_is_type_256 = true;
- dap_chain_256_tx_out_cond_t *l_tx_out = (dap_chain_256_tx_out_cond_t *)l_list_tmp->data;
- if (emission_flag) {
- l_value_256 = l_tx_out->header.value;
- }
- if (l_multichannel) { // out_cond have no field .token
- log_it(L_WARNING, "No conditional output support for multichannel transaction");
- l_err_num = -18;
- break;
- }
- l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
+ } break;
+ default: {}
}
-
- if (l_is_type_256) { // 256
- if (l_multichannel) {
- HASH_FIND_STR(l_values_from_cur_tx_256, l_token, l_value_cur_256);
- if (!l_value_cur_256) {
- l_value_cur_256 = DAP_NEW_Z(dap_chain_ledger_tokenizer_256_t);
- strcpy(l_value_cur_256->token_ticker, l_token);
- HASH_ADD_STR(l_values_from_cur_tx_256, token_ticker, l_value_cur_256);
- }
- }
- SUM_256_256(l_value_cur_256->sum, l_value_256, &l_value_cur_256->sum);
- } else {
- if (l_multichannel) {
- HASH_FIND_STR(l_values_from_cur_tx, l_token, l_value_cur);
- if (!l_value_cur) {
- l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
- strcpy(l_value_cur->token_ticker, l_token);
- HASH_ADD_STR(l_values_from_cur_tx, token_ticker, l_value_cur);
- }
+ if (l_multichannel) {
+ HASH_FIND_STR(l_values_from_cur_tx, l_token, l_value_cur);
+ if (!l_value_cur) {
+ l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
+ strcpy(l_value_cur->token_ticker, l_token);
+ HASH_ADD_STR(l_values_from_cur_tx, token_ticker, l_value_cur);
}
- l_value_cur->sum += l_value;
}
+ SUM_256_256(l_value_cur->sum, l_value, &l_value_cur->sum);
// Get permissions for token
l_token_item = NULL;
@@ -2262,56 +2100,37 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
}
+
if ( l_list_out )
dap_list_free(l_list_out);
// Additional check whether the transaction is first
- while (l_is_first_transaction && !l_err_num) {
+ if (l_is_first_transaction && !l_err_num) {
if (l_ledger_priv->check_token_emission) { // Check the token emission
dap_chain_datum_token_emission_t * l_token_emission = dap_chain_ledger_token_emission_find(a_ledger, l_token, l_emission_hash);
if (l_token_emission) {
- if (l_token_emission->hdr.value != l_value_cur->sum &&
- !EQUAL_256(l_token_emission->hdr.value_256, l_value_cur_256->sum) ) {
+ if (!EQUAL_256(l_token_emission->hdr.value_256, l_value_cur->sum)) {
l_err_num = -10;
}
l_value_cur = NULL;
- l_value_cur_256 = NULL;
} else {
log_it(L_WARNING, "Emission for tx_token wasn't found");
l_err_num = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION;
- break;
}
}
- break;
}
-
- while (!l_is_first_transaction && !l_err_num) {
- bool l_err_flag = false;
- bool l_err_flag_256 = false;
+ if (!l_is_first_transaction && !l_err_num) {
HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
HASH_FIND_STR(l_values_from_cur_tx, l_value_cur->token_ticker, l_res);
- if (!l_res || (l_res->sum != l_value_cur->sum) ){ //&& !EQUAL_256(l_res->sum_256,l_value_cur->sum_256) ) ) {
- if(s_debug_more)
- log_it(L_ERROR, "Sum of values in out items of current tx (%"DAP_UINT64_FORMAT_U") is not equal outs from previous tx (%"DAP_UINT64_FORMAT_U") for token %s",
- l_res ? l_res->sum : 0, l_value_cur->sum, l_value_cur->token_ticker);
- l_err_flag = true;
- break;
- }
- }
- HASH_ITER(hh, l_values_from_prev_tx_256, l_value_cur_256, l_tmp_256) {
- HASH_FIND_STR(l_values_from_cur_tx_256, l_value_cur_256->token_ticker, l_res_256);
- if (!l_res_256 || !EQUAL_256(l_res_256->sum,l_value_cur_256->sum) ) {
+ if (!l_res || !EQUAL_256(l_res->sum, l_value_cur->sum) ) {
if(s_debug_more)
log_it(L_ERROR, "Sum of values in out items of current tx 256 (%s) is not equal outs from previous tx (%s) for token %s",
- dap_chain_u256tostr( ( l_res_256 ? l_res_256->sum : uint256_0) ), dap_chain_u256tostr(l_value_cur_256->sum), l_value_cur_256->token_ticker);
- l_err_flag_256 = true;
+ dap_chain_balance_print(l_res ? l_res->sum : uint256_0), dap_chain_balance_print(l_value_cur->sum), l_value_cur->token_ticker);
+ l_err_num = -12;
break;
}
}
- if ( l_err_flag && l_err_flag_256 )
- l_err_num = -12;
- break;
}
HASH_ITER(hh, l_values_from_prev_tx, l_value_cur, l_tmp) {
@@ -2320,15 +2139,6 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
HASH_ITER(hh, l_values_from_cur_tx, l_value_cur, l_tmp) {
DAP_DELETE(l_value_cur);
}
-
- // 256
- HASH_ITER(hh, l_values_from_prev_tx_256, l_value_cur_256, l_tmp_256) {
- DAP_DELETE(l_value_cur_256);
- }
- HASH_ITER(hh, l_values_from_cur_tx_256, l_value_cur_256, l_tmp_256) {
- DAP_DELETE(l_value_cur_256);
- }
-
if (!a_list_bound_items || l_err_num) {
dap_list_free_full(l_list_bound_items, free);
} else {
@@ -2361,7 +2171,7 @@ int dap_chain_ledger_tx_add_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *
a_ledger, a_tx, &l_list_bound_items, &l_list_tx_out)) < 0){
if(s_debug_more)
log_it (L_DEBUG, "dap_chain_ledger_tx_add_check() tx not passed the check: code %d ",l_ret_check);
- return -1;
+ return l_ret_check;
}
dap_chain_hash_fast_t *l_tx_hash = dap_chain_node_datum_tx_calc_hash(a_tx);
char l_tx_hash_str[70];
@@ -2374,10 +2184,9 @@ int dap_chain_ledger_tx_add_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *
static int s_balance_cache_update(dap_ledger_t *a_ledger, dap_ledger_wallet_balance_t *a_balance)
{
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_BALANCES_STR);
- // uint128_t *l_balance_value = DAP_NEW_Z(uint128_t);
uint256_t *l_balance_value = DAP_NEW_Z(uint256_t);
*l_balance_value = a_balance->balance;
- if (!dap_chain_global_db_gr_set(dap_strdup(a_balance->key), l_balance_value, sizeof(uint256_t/*uint128_t*/), l_gdb_group)) {
+ if (!dap_chain_global_db_gr_set(dap_strdup(a_balance->key), l_balance_value, sizeof(uint256_t), l_gdb_group)) {
if(s_debug_more)
log_it(L_WARNING, "Ledger cache mismatch");
DAP_DELETE(l_balance_value);
@@ -2433,7 +2242,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
if (l_item_tmp) {
if(s_debug_more)
log_it(L_WARNING, "Transaction %s already present in the cache", l_tx_hash_str);
- ret = 1;
+ ret = -1;
goto FIN;
}
@@ -2481,7 +2290,6 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
ret = l_ret_check;
goto FIN;
}
-
if(s_debug_more)
log_it ( L_DEBUG, "dap_chain_ledger_tx_add() check passed for tx %s",l_tx_hash_str);
@@ -2494,58 +2302,38 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
// find all bound pairs 'in' and 'out'
dap_list_t *l_list_tmp = l_list_bound_items;
char *l_ticker_trl = NULL, *l_ticker_old_trl = NULL;
-
bool l_stake_updated = false;
-
// Update balance: deducts
while(l_list_tmp) {
dap_chain_ledger_tx_bound_t *bound_item = l_list_tmp->data;
void *l_item_in = *(void **)&bound_item->in;
- void *l_item_out = *(void **)&bound_item->out;
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_item_in;
- dap_chain_tx_item_type_t l_out_type = *(uint8_t *)l_item_out;
-
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)
- // : dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext->token);
+ dap_chain_tx_item_type_t l_out_type = *(uint8_t *)l_prev_item_out;
if ( *l_prev_item_out->cache_data.token_tiker )
l_ticker_trl = dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_tiker);
- else if ( l_out_type == TX_ITEM_TYPE_256_OUT || l_out_type == TX_ITEM_TYPE_256_OUT_EXT ) // 256
+ else if ( l_out_type == TX_ITEM_TYPE_OUT_EXT) // 256
l_ticker_trl = dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext_256->token);
- else
- l_ticker_trl = 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;
}
l_ticker_old_trl = dap_stpcpy(l_token_ticker_old, l_token_ticker);
int l_tx_prev_out_used_idx;
-
if (l_type == TX_ITEM_TYPE_IN) {
dap_chain_tx_in_t *l_tx_in = bound_item->in.tx_cur_in;
dap_ledger_wallet_balance_t *wallet_balance = NULL;
- //void *l_item_out = *(void **)&bound_item->out;
- uint256_t l_value = uint256_0;
-
+ uint256_t l_value = {};
dap_chain_addr_t *l_addr = NULL;
switch (l_out_type) {
- case TX_ITEM_TYPE_256_OUT: l_addr = &bound_item->out.tx_prev_out_256->addr; break;
+ case TX_ITEM_TYPE_OUT_256: l_addr = &bound_item->out.tx_prev_out_256->addr; break;
case TX_ITEM_TYPE_OUT: l_addr = &bound_item->out.tx_prev_out->addr; break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_addr = &bound_item->out.tx_prev_out_ext_256->addr; break;
- case TX_ITEM_TYPE_OUT_EXT: l_addr = &bound_item->out.tx_prev_out_ext->addr; break;
+ case TX_ITEM_TYPE_OUT_EXT: l_addr = &bound_item->out.tx_prev_out_ext_256->addr; break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
}
-
- // dap_chain_addr_t *l_addr = (l_out_type == TX_ITEM_TYPE_OUT || l_out_type == TX_ITEM_TYPE_256_OUT) ?
- // &bound_item->out.tx_prev_out->addr :
- // &bound_item->out.tx_prev_out_ext->addr;
-
char *l_addr_str = dap_chain_addr_to_str(l_addr);
char *l_wallet_balance_key = dap_strjoin(" ", l_addr_str, l_token_ticker, (char*)NULL);
pthread_rwlock_rdlock(&PVT(a_ledger)->balance_accounts_rwlock);
@@ -2553,18 +2341,17 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
pthread_rwlock_unlock(&PVT(a_ledger)->balance_accounts_rwlock);
if (wallet_balance) {
switch (l_out_type) {
- case TX_ITEM_TYPE_256_OUT: l_value = bound_item->out.tx_prev_out_256->header.value; break;
+ case TX_ITEM_TYPE_OUT_256: l_value = bound_item->out.tx_prev_out_256->header.value; break;
case TX_ITEM_TYPE_OUT: l_value = GET_256_FROM_64(bound_item->out.tx_prev_out->header.value); break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_value = bound_item->out.tx_prev_out_ext_256->header.value; break;
- case TX_ITEM_TYPE_OUT_EXT: l_value = GET_256_FROM_64(bound_item->out.tx_prev_out_ext->header.value); break;
+ case TX_ITEM_TYPE_OUT_EXT: l_value = bound_item->out.tx_prev_out_ext_256->header.value; break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
}
if(s_debug_more)
- log_it(L_DEBUG,"SPEND %s from addr: %s", dap_chain_u256tostr(l_value), l_wallet_balance_key);
-
+ log_it(L_DEBUG,"SPEND %s from addr: %s", dap_chain_balance_print(l_value), l_wallet_balance_key);
+
SUBTRACT_256_256(wallet_balance->balance, l_value, &wallet_balance->balance);
// Update the cache
@@ -2575,17 +2362,15 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
}
DAP_DELETE(l_addr_str);
DAP_DELETE(l_wallet_balance_key);
-
/// Mark 'out' item in cache because it used
l_tx_prev_out_used_idx = l_tx_in->header.tx_out_prev_idx;
} else { // TX_ITEM_TYPE_IN_COND
-
// all balance deducts performed with previous conditional transaction
dap_chain_tx_in_cond_t *l_tx_in_cond = bound_item->in.tx_cur_in_cond;
/// Mark 'out' item in cache because it used
l_tx_prev_out_used_idx = l_tx_in_cond->header.tx_out_prev_idx;
// Update stakes if any
- dap_chain_tx_out_cond_t *l_cond = bound_item->out.tx_prev_out_cond;
+ dap_chain_tx_out_cond_t *l_cond = bound_item->out.tx_prev_out_cond_256;
if (l_cond->header.subtype == DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE) {
dap_chain_ledger_verificator_t *l_verificator;
int l_tmp = (int)DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_UPDATE;
@@ -2598,7 +2383,6 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
l_stake_updated = true;
}
}
-
// add a used output
memcpy(&(l_prev_item_out->cache_data.tx_hash_spent_fast[l_tx_prev_out_used_idx]), l_tx_hash, sizeof(dap_chain_hash_fast_t));
l_prev_item_out->cache_data.n_outs_used++;
@@ -2631,11 +2415,9 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
goto FIN;
}
}
-
// go to next previous transaction
l_list_tmp = dap_list_next(l_list_tmp);
}
-
if (l_list_bound_items)
dap_list_free_full(l_list_bound_items, free);
@@ -2645,18 +2427,15 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
//dap_list_t *l_base_tx_list = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_TOKEN, &l_base_tx_count );
//if (l_base_tx_count >=1 && l_base_tx_list){
dap_chain_tx_token_t * l_tx_token = (dap_chain_tx_token_t *) dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_TOKEN, NULL);
- dap_chain_tx_token_t * l_tx_token_256 = (dap_chain_tx_token_t *) dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_256_TOKEN, NULL);
-
- if ( l_tx_token_256 )
- l_ticker_trl = dap_stpcpy(l_token_ticker, l_tx_token_256->header.ticker);
- else if (l_tx_token)
+ if (l_tx_token)
l_ticker_trl = dap_stpcpy(l_token_ticker, l_tx_token->header.ticker);
+ //}
}
//Update balance : raise
for (dap_list_t *l_tx_out = l_list_tx_out; l_tx_out; l_tx_out = dap_list_next(l_tx_out)) {
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_tx_out->data;
- if (l_type == TX_ITEM_TYPE_OUT_COND || l_type == TX_ITEM_TYPE_256_OUT_COND) {
+ if (l_type == TX_ITEM_TYPE_OUT_COND) {
// Update stakes if any
dap_chain_tx_out_cond_t *l_cond = (dap_chain_tx_out_cond_t *)l_tx_out->data;
if (l_cond->header.subtype == DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE && !l_stake_updated) {
@@ -2671,32 +2450,25 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
}
continue; // balance raise will be with next conditional transaction
}
-
dap_chain_tx_out_t *l_out_item = NULL;
dap_chain_256_tx_out_t *l_out_item_256 = NULL;
- dap_chain_tx_out_ext_t *l_out_item_ext = NULL;
- dap_chain_256_tx_out_ext_t *l_out_item_ext_256 = NULL;
+ dap_chain_tx_out_ext_t *l_out_item_ext_256 = NULL;
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT: l_out_item_256 = (dap_chain_256_tx_out_t *)l_tx_out->data; break;
+ case TX_ITEM_TYPE_OUT_256: l_out_item_256 = (dap_chain_256_tx_out_t *)l_tx_out->data; break;
case TX_ITEM_TYPE_OUT: l_out_item = (dap_chain_tx_out_t *)l_tx_out->data; break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_out_item_ext_256 = (dap_chain_256_tx_out_ext_t *)l_tx_out->data; break;
- case TX_ITEM_TYPE_OUT_EXT: l_out_item_ext = (dap_chain_tx_out_ext_t *)l_tx_out->data; break;
+ case TX_ITEM_TYPE_OUT_EXT: l_out_item_ext_256 = (dap_chain_tx_out_ext_t *)l_tx_out->data; break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
}
- if ((l_out_item||l_out_item_ext||l_out_item_256||l_out_item_ext_256) && l_ticker_trl) {
- // dap_chain_addr_t *l_addr = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ?
- // &l_out_item->addr :
- // &l_out_item_ext->addr;
+ if ((l_out_item||l_out_item_256||l_out_item_ext_256) && l_ticker_trl) {
dap_chain_addr_t *l_addr;
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT: l_addr = &l_out_item_256->addr; break;
+ case TX_ITEM_TYPE_OUT_256: l_addr = &l_out_item_256->addr; break;
case TX_ITEM_TYPE_OUT: l_addr = &l_out_item->addr; break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_addr = &l_out_item_ext_256->addr; break;
- case TX_ITEM_TYPE_OUT_EXT: l_addr = &l_out_item_ext->addr; break;
+ case TX_ITEM_TYPE_OUT_EXT: l_addr = &l_out_item_ext_256->addr; break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
@@ -2708,32 +2480,27 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
// l_token_ticker, l_addr_str);
dap_ledger_wallet_balance_t *wallet_balance = NULL;
if (l_multichannel) {
- l_ticker_trl = dap_stpcpy(l_token_ticker, l_out_item_ext->token);
+ l_ticker_trl = dap_stpcpy(l_token_ticker, l_out_item_ext_256->token);
}
char *l_wallet_balance_key = dap_strjoin(" ", l_addr_str, l_token_ticker, (char*)NULL);
-
- uint64_t l_value = 0;
- uint256_t l_value_256 = uint256_0;
+ uint256_t l_value_256 = {};
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT: l_value_256 = l_out_item_256->header.value; break; // _256
+ case TX_ITEM_TYPE_OUT_256: l_value_256 = l_out_item_256->header.value; break; // _256
case TX_ITEM_TYPE_OUT: l_value_256 = GET_256_FROM_64(l_out_item->header.value); break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_value_256 = l_out_item_ext_256->header.value; break; // _256
- case TX_ITEM_TYPE_OUT_EXT: l_value_256 = GET_256_FROM_64(l_out_item_ext->header.value); break;
+ case TX_ITEM_TYPE_OUT_EXT: l_value_256 = l_out_item_ext_256->header.value; break; // _256
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
}
- // l_value = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ? l_out_item->header.value : l_out_item_ext->header.value;
if(s_debug_more)
- log_it (L_DEBUG,"GOT %s to addr: %s", dap_chain_u256tostr(l_value_256), l_wallet_balance_key);
+ log_it (L_DEBUG,"GOT %s to addr: %s", dap_chain_balance_print(l_value_256), l_wallet_balance_key);
pthread_rwlock_rdlock(&l_ledger_priv->balance_accounts_rwlock);
HASH_FIND_STR(PVT(a_ledger)->balance_accounts, l_wallet_balance_key, wallet_balance);
pthread_rwlock_unlock(&l_ledger_priv->balance_accounts_rwlock);
if (wallet_balance) {
if(s_debug_more)
log_it(L_DEBUG, "Balance item is present in cache");
-
SUM_256_256(wallet_balance->balance, l_value_256, &wallet_balance->balance);
DAP_DELETE (l_wallet_balance_key);
// Update the cache
@@ -2742,9 +2509,7 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
wallet_balance = DAP_NEW_Z(dap_ledger_wallet_balance_t);
wallet_balance->key = l_wallet_balance_key;
strcpy(wallet_balance->token_ticker, l_token_ticker);
-
SUM_256_256(wallet_balance->balance, l_value_256, &wallet_balance->balance);
-
if(s_debug_more)
log_it(L_DEBUG,"!!! Create new balance item: %s %s", l_addr_str, l_token_ticker);
pthread_rwlock_wrlock(&l_ledger_priv->balance_accounts_rwlock);
@@ -2785,20 +2550,10 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
if (!l_ticker_trl) { //No token ticker in previous txs
if(s_debug_more)
log_it(L_DEBUG, "No token ticker in previous txs");
- //int l_tokens_count = 0;
- //dap_list_t *l_tokens_list = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_TOKEN, &l_tokens_count );
- //if ( l_tokens_count>0 ){
- //dap_chain_tx_token_t * l_token = (dap_chain_tx_token_t*) l_tokens_list->data;
dap_chain_tx_token_t *l_token = (dap_chain_tx_token_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_TOKEN, NULL);
- // 256
- dap_chain_tx_token_t *l_token_256 = (dap_chain_tx_token_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_256_TOKEN, NULL);
l_ticker_trl = l_token
? dap_stpcpy(l_token_ticker, l_token->header.ticker)
- : ( l_token_256 // 256
- ? dap_stpcpy(l_token_ticker, l_token_256->header.ticker)
- : NULL );
- //dap_list_free(l_tokens_list);
- //}
+ : NULL;
}
if (l_ticker_trl && !l_multichannel)
dap_stpcpy(l_item_tmp->cache_data.token_tiker, l_token_ticker);
@@ -2886,7 +2641,7 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
/**
* Delete all transactions from the cache
*/
-void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
+void dap_chain_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db)
{
dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
const int l_hash_str_size = DAP_CHAIN_HASH_FAST_SIZE * 2 + 2;
@@ -2903,8 +2658,10 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
HASH_ITER(hh, l_ledger_priv->ledger_items , l_item_current, l_item_tmp) {
DAP_DELETE(l_item_current->tx);
HASH_DEL(l_ledger_priv->ledger_items, l_item_current);
- dap_chain_hash_fast_to_str(&l_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);
+ 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_global_db_gr_del(dap_strdup(l_hash_str), l_gdb_group);
+ }
DAP_DELETE(l_item_current);
}
DAP_DELETE(l_gdb_group);
@@ -2913,8 +2670,10 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
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);
- dap_chain_hash_fast_to_str(&l_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);
+ 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_global_db_gr_del(dap_strdup(l_hash_str), l_gdb_group);
+ }
DAP_DELETE(l_item_current->tx);
DAP_DELETE(l_item_current);
}
@@ -2925,7 +2684,8 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_BALANCES_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);
- dap_chain_global_db_gr_del(l_balance_current->key, l_gdb_group);
+ if (!a_preserve_db)
+ dap_chain_global_db_gr_del(l_balance_current->key, l_gdb_group);
DAP_DELETE(l_balance_current);
}
DAP_DELETE(l_gdb_group);
@@ -2935,8 +2695,10 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
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);
- 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);
+ 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);
}
@@ -2949,13 +2711,16 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
pthread_rwlock_wrlock(&l_token_current->token_emissions_rwlock);
HASH_ITER(hh, l_token_current->token_emissions, l_emission_current, l_emission_tmp) {
HASH_DEL(l_token_current->token_emissions, l_emission_current);
- 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);
+ 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);
}
pthread_rwlock_unlock(&l_token_current->token_emissions_rwlock);
- dap_chain_global_db_gr_del(dap_strdup(l_token_current->ticker), l_gdb_group);
+ if (!a_preserve_db)
+ dap_chain_global_db_gr_del(dap_strdup(l_token_current->ticker), l_gdb_group);
DAP_DELETE(l_token_current->datum_token);
pthread_rwlock_destroy(&l_token_current->token_emissions_rwlock);
DAP_DELETE(l_token_current);
@@ -2963,6 +2728,11 @@ void dap_chain_ledger_purge(dap_ledger_t *a_ledger)
DAP_DELETE(l_gdb_group);
DAP_DELETE(l_emissions_gdb_group);
+ l_ledger_priv->last_tx.found = true;
+ l_ledger_priv->last_thres_tx.found = true;
+ l_ledger_priv->last_emit.found = true;
+ l_ledger_priv->last_ticker.found = true;
+
pthread_rwlock_unlock(&l_ledger_priv->ledger_rwlock);
pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
pthread_rwlock_unlock(&l_ledger_priv->treshold_emissions_rwlock);
@@ -3049,7 +2819,7 @@ uint256_t dap_chain_ledger_calc_balance(dap_ledger_t *a_ledger, const dap_chain_
if (l_balance_item) {
if(s_debug_more)
log_it (L_INFO,"Found address in cache with balance %s",
- dap_chain_u256tostr(l_balance_item->balance));
+ dap_chain_balance_print(l_balance_item->balance));
l_ret = l_balance_item->balance;
} else {
if (s_debug_more)
@@ -3067,15 +2837,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
if(!a_addr || !dap_chain_addr_check_sum(a_addr))
return balance;
- /* proto
- *
- dap_ledger_wallet_balance_t *wallet_balance = NULL;
- HASH_FIND(hh, balance_accounts, a_addr, sizeof(*a_addr), wallet_balance);
- if (wallet_balance) {
- balance = wallet_balance->balance;
- }
- */
dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
dap_chain_ledger_tx_item_t *l_iter_current, *l_item_tmp;
pthread_rwlock_rdlock(&l_ledger_priv->ledger_rwlock);
@@ -3123,7 +2885,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
}
}
}
- if (l_type == TX_ITEM_TYPE_256_OUT) { // 256
+ if (l_type == TX_ITEM_TYPE_OUT_256) { // 256
const dap_chain_256_tx_out_t *l_tx_out = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
// const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
// Check for token name
@@ -3138,23 +2900,8 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
}
}
}
- if (l_type == TX_ITEM_TYPE_OUT_EXT) {
+ if (l_type == TX_ITEM_TYPE_OUT_EXT) { // 256
const dap_chain_tx_out_ext_t *l_tx_out = (const dap_chain_tx_out_ext_t*) l_list_tmp->data;
- // Check for token name
- if (!strcmp(a_token_ticker, l_tx_out->token))
- { // 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
- if(!dap_chain_ledger_item_is_used_out(l_iter_current, l_out_idx_tmp) &&
- dap_chain_datum_tx_verify_sign(l_cur_tx)) {
- uint256_t l_add = dap_chain_uint256_from(l_tx_out->header.value);
- SUM_256_256(balance, l_add, &balance);
- }
- }
- }
- }
- if (l_type == TX_ITEM_TYPE_256_OUT_EXT) { // 256
- const dap_chain_256_tx_out_ext_t *l_tx_out = (const dap_chain_256_tx_out_ext_t*) l_list_tmp->data;
// const dap_chain_tx_out_ext_t *l_tx_out = (const dap_chain_tx_out_ext_t*) l_list_tmp->data;
// Check for token name
if (!strcmp(a_token_ticker, l_tx_out->token))
@@ -3175,6 +2922,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
return balance;
}
+
/**
* Get the transaction in the cache by the addr in out item
*
@@ -3379,10 +3127,10 @@ dap_chain_datum_tx_t* dap_chain_ledger_tx_cache_find_out_cond(dap_ledger_t *a_le
* a_public_key[in] public key that signed the transaction
* a_public_key_size[in] public key size
*/
-uint64_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, dap_chain_addr_t *a_addr,
+uint256_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, dap_chain_addr_t *a_addr,
dap_chain_tx_out_cond_t **tx_out_cond)
{
- uint64_t l_ret_value = 0;
+ uint256_t l_ret_value = {};
dap_chain_datum_tx_t *l_tx_tmp;
dap_chain_hash_fast_t l_tx_first_hash = { 0 }; // start hash
@@ -3401,7 +3149,7 @@ uint64_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, da
// TODO check relations a_addr with cond_data and public key
if(l_tx_out_cond) {
- l_ret_value += l_tx_out_cond->header.value;
+ l_ret_value = l_tx_out_cond->header.value;
if(tx_out_cond)
*tx_out_cond = l_tx_out_cond;
}
@@ -3420,13 +3168,12 @@ uint64_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, da
* @return
*/
dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, const char *a_token_ticker, const dap_chain_addr_t *a_addr_from,
- uint64_t a_value_need, uint64_t *a_value_transfer)
+ uint256_t a_value_need, uint256_t *a_value_transfer)
{
dap_list_t *l_list_used_out = NULL; // list of transaction with 'out' items
dap_chain_hash_fast_t l_tx_cur_hash = { 0 };
- uint64_t l_value_transfer = 0;
- //uint256_t l_value_transfer = uint256_0;
- while(l_value_transfer < a_value_need)
+ uint256_t l_value_transfer = {};
+ while(compare256(l_value_transfer, a_value_need) == -1)
{
// Get the transaction in the cache by the addr in out item
dap_chain_datum_tx_t *l_tx = dap_chain_ledger_tx_find_by_addr(a_ledger, a_token_ticker, a_addr_from,
@@ -3439,11 +3186,7 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
uint32_t l_out_idx_tmp = 0; // current index of 'out' item
for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_out_idx_tmp++) {
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_list_tmp->data;
- if (l_type == TX_ITEM_TYPE_OUT_COND || l_type == TX_ITEM_TYPE_256_OUT_COND) {
- continue;
- }
- // uint64_t l_value;
- uint256_t l_value = uint256_0;
+ uint256_t l_value = {};
switch (l_type) {
case TX_ITEM_TYPE_OUT: {
dap_chain_tx_out_t *l_out = (dap_chain_tx_out_t *)l_list_tmp->data;
@@ -3452,7 +3195,7 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
}
l_value = GET_256_FROM_64(l_out->header.value);
} break;
- case TX_ITEM_TYPE_256_OUT: {
+ case TX_ITEM_TYPE_OUT_256: {
dap_chain_256_tx_out_t *l_out = (dap_chain_256_tx_out_t *)l_list_tmp->data;
if ( IS_ZERO_256(l_out->header.value) || memcmp(a_addr_from, &l_out->addr, sizeof(dap_chain_addr_t))) {
continue;
@@ -3461,48 +3204,27 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
} break;
case TX_ITEM_TYPE_OUT_EXT: {
dap_chain_tx_out_ext_t *l_out_ext = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
- if (!l_out_ext->header.value || memcmp(a_addr_from, &l_out_ext->addr, sizeof(dap_chain_addr_t)) ||
- strcmp((char *)a_token_ticker, l_out_ext->token)) {
- continue;
- }
- l_value = GET_256_FROM_64(l_out_ext->header.value);
- } break;
- case TX_ITEM_TYPE_256_OUT_EXT: {
- dap_chain_256_tx_out_ext_t *l_out_ext = (dap_chain_256_tx_out_ext_t *)l_list_tmp->data;
- if ( IS_ZERO_256(l_out_ext->header.value) || memcmp(a_addr_from, &l_out_ext->addr, sizeof(dap_chain_addr_t)) ||
+ if (IS_ZERO_256(l_out_ext->header.value) || memcmp(a_addr_from, &l_out_ext->addr, sizeof(dap_chain_addr_t)) ||
strcmp((char *)a_token_ticker, l_out_ext->token)) {
continue;
}
l_value = l_out_ext->header.value;
} break;
+ case TX_ITEM_TYPE_OUT_COND:
+ case TX_ITEM_TYPE_OUT_256_COND:
+ default:
+ continue;
}
- // if (l_type == TX_ITEM_TYPE_OUT) {
- // dap_chain_tx_out_t *l_out = (dap_chain_tx_out_t *)l_list_tmp->data;
- // if (!l_out->header.value || memcmp(a_addr_from, &l_out->addr, sizeof(dap_chain_addr_t))) {
- // continue;
- // }
- // l_value = l_out->header.value;
- // } else { // TX_ITEM_TYPE_OUT_EXT
- // dap_chain_tx_out_ext_t *l_out_ext = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
- // if (!l_out_ext->header.value || memcmp(a_addr_from, &l_out_ext->addr, sizeof(dap_chain_addr_t)) ||
- // strcmp((char *)a_token_ticker, l_out_ext->token)) {
- // continue;
- // }
- // l_value = l_out_ext->header.value;
- // }
// Check whether used 'out' items
-
if (!dap_chain_ledger_tx_hash_is_used_out_item (a_ledger, &l_tx_cur_hash, l_out_idx_tmp)) {
- list_used_item_t *item = DAP_NEW(list_used_item_t);
- memcpy(&item->tx_hash_fast, &l_tx_cur_hash, sizeof(dap_chain_hash_fast_t));
- item->num_idx_out = l_out_idx_tmp;
- item->value = dap_chain_uint256_to(l_value); // this is temporary for compatibility :-)
- l_list_used_out = dap_list_append(l_list_used_out, item);
- l_value_transfer += item->value;
- //SUM_256_256(l_value_transfer, item->value, &l_value_transfer);
+ list_used_item_t *l_item = DAP_NEW(list_used_item_t);
+ memcpy(&l_item->tx_hash_fast, &l_tx_cur_hash, sizeof(dap_chain_hash_fast_t));
+ l_item->num_idx_out = l_out_idx_tmp;
+ l_item->value = l_value;
+ l_list_used_out = dap_list_append(l_list_used_out, l_item);
+ SUM_256_256(l_value_transfer, l_item->value, &l_value_transfer);
// already accumulated the required value, finish the search for 'out' items
- if (l_value_transfer >= a_value_need) {
- //if (compare256(l_value_transfer, a_value_need) >= 0) {
+ if (compare256(l_value_transfer, a_value_need) != -1) {
break;
}
}
@@ -3511,8 +3233,7 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
}
// nothing to tranfer (not enough funds)
- if(!l_list_used_out || l_value_transfer < a_value_need) {
- // if(!l_list_used_out || compare256(l_value_transfer, a_value_need) < 0) {
+ if(!l_list_used_out || compare256(l_value_transfer, a_value_need) == -1) {
dap_list_free_full(l_list_used_out, free);
return NULL;
}
diff --git a/modules/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index 65d3b5840f3d8a6dbd66b95dc4af3abd0ce1f566..a52ded135cc488ec961a53daf28f3b2bc7738501 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -53,6 +53,7 @@ typedef struct dap_chain_atom_iter{
void * _inheritor;
} dap_chain_atom_iter_t;
+
typedef enum dap_chain_atom_verify_res{
ATOM_ACCEPT=0,
ATOM_PASS=1,
@@ -97,9 +98,6 @@ typedef enum dap_chain_type
CHAIN_TYPE_CA,
CHAIN_TYPE_SIGNER,
CHAIN_TYPE_LAST
- // CHAIN_TYPE_256_TOKEN, // 256
- // CHAIN_TYPE_256_EMISSION, // 256
- // CHAIN_TYPE_256_TX, // 256
} dap_chain_type_t;
typedef struct dap_chain{
@@ -187,5 +185,5 @@ dap_chain_t * dap_chain_load_from_cfg(dap_ledger_t* a_ledger,const char * a_chai
void dap_chain_delete(dap_chain_t * a_chain);
void dap_chain_add_callback_notify(dap_chain_t * a_chain, dap_chain_callback_notify_t a_callback, void * a_arg);
-dap_chain_atom_ptr_t dap_chain_get_atom_by_hash(dap_chain_t * a_chain, dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size, dap_chain_cell_id_t a_cell_id);
-bool dap_chain_get_atom_last_hash(dap_chain_t * a_chain, dap_hash_fast_t * a_atom_hash, dap_chain_cell_id_t a_cell_id);
+dap_chain_atom_ptr_t dap_chain_get_atom_by_hash(dap_chain_t * a_chain, dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size);
+bool dap_chain_get_atom_last_hash(dap_chain_t *a_chain, dap_hash_fast_t *a_atom_hash, dap_chain_cell_id_t a_cel_id);
diff --git a/modules/chain/include/dap_chain_ledger.h b/modules/chain/include/dap_chain_ledger.h
index aa8fc05e8c91ed891fd549652f3caf7af90f4998..d88df0abbbc2b6498b39d7e2f80e8a40ff5f9daa 100644
--- a/modules/chain/include/dap_chain_ledger.h
+++ b/modules/chain/include/dap_chain_ledger.h
@@ -57,6 +57,8 @@ typedef bool (* dap_chain_ledger_verificator_callback_t)(dap_chain_tx_out_cond_t
#define DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS -111
// Error code for no emission for a transaction (candidate to threshold)
#define DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION -112
+// Error code for no token for an emission (candidate to threshold)
+#define DAP_CHAIN_CS_VERIFY_CODE_TX_NO_TOKEN -113
#define DAP_CHAIN_LEDGER_TOKENS_STR "tokens"
#define DAP_CHAIN_LEDGER_EMISSIONS_STR "emissions"
@@ -120,14 +122,13 @@ int dap_chain_ledger_token_ticker_check(dap_ledger_t * a_ledger, const char *a_t
*
*/
-int dap_chain_ledger_token_add(dap_ledger_t * a_ledger,dap_chain_datum_token_t *a_token, size_t a_token_size);
-int dap_chain_ledger_token_load(dap_ledger_t * a_ledger,dap_chain_datum_token_t *a_token, size_t a_token_size);
-int dap_chain_ledger_token_decl_add_check(dap_ledger_t * a_ledger,dap_chain_datum_token_t *a_token);
+int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token, size_t a_token_size);
+int dap_chain_ledger_token_load(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token, size_t a_token_size);
+int dap_chain_ledger_token_decl_add_check(dap_ledger_t *a_ledger, dap_chain_datum_token_t *a_token);
dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger);
/**
* Add token emission datum
*/
-
int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size);
int dap_chain_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size);
@@ -160,7 +161,12 @@ int dap_chain_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_
/**
* Delete all transactions from the cache
*/
-void dap_chain_ledger_purge(dap_ledger_t *a_ledger);
+void dap_chain_ledger_purge(dap_ledger_t *a_ledger, bool a_preserve_db);
+
+/**
+ * End of load mode with no chackes for incoming datums
+ */
+void dap_chain_ledger_load_end(dap_ledger_t *a_ledger);
/**
* Return number transactions from the cache
@@ -205,13 +211,13 @@ dap_chain_datum_tx_t* dap_chain_ledger_tx_cache_find_out_cond(dap_ledger_t *a_le
dap_chain_tx_out_cond_t **a_out_cond, int *a_out_cond_idx, char *a_token_ticker);
// Get the value from all transactions in the cache with out_cond item
-uint64_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, dap_chain_addr_t *a_addr,
+uint256_t dap_chain_ledger_tx_cache_get_out_cond_value(dap_ledger_t *a_ledger, dap_chain_addr_t *a_addr,
dap_chain_tx_out_cond_t **tx_out_cond);
// Get the list of 'out' items from previous transactions with summary value >= than a_value_need
// Put this summary value to a_value_transfer
dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, const char *a_token_ticker, const dap_chain_addr_t *a_addr_from,
- uint64_t a_value_need, uint64_t *a_value_transfer);
+ uint256_t a_value_need, uint256_t *a_value_transfer);
int dap_chain_ledger_verificator_rwlock_init(void);
// Add new verificator callback with associated subtype. Returns 1 if callback replaced, overwise returns 0
int dap_chain_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_chain_ledger_verificator_callback_t a_callback);
diff --git a/modules/channel/chain-net-srv/CMakeLists.txt b/modules/channel/chain-net-srv/CMakeLists.txt
index 99175488200aa2962f42c06c1e8628b57a8731b2..08b1ea5c1996bb155320f30f87a658a9759dab1d 100644
--- a/modules/channel/chain-net-srv/CMakeLists.txt
+++ b/modules/channel/chain-net-srv/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_stream_ch_chain_net_srv)
file(GLOB DAP_STREAM_CH_CHAIN_NET_SRV_SRCS *.c)
diff --git a/modules/channel/chain-net/CMakeLists.txt b/modules/channel/chain-net/CMakeLists.txt
index c7166b01ad46da9f45d0921c93ecac3a75e952af..66388711cbe54cde8c6fdd278b84965ecb5b744d 100644
--- a/modules/channel/chain-net/CMakeLists.txt
+++ b/modules/channel/chain-net/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_stream_ch_chain_net)
file(GLOB DAP_STREAM_CH_CHAIN_NET_SRCS *.c)
diff --git a/modules/channel/chain-net/dap_stream_ch_chain_net.c b/modules/channel/chain-net/dap_stream_ch_chain_net.c
index 26ad6039af414d7ecac28bf899e8c6c095ddad43..ff6ba4a25cab33352db6f99374310c1cccd3f101 100644
--- a/modules/channel/chain-net/dap_stream_ch_chain_net.c
+++ b/modules/channel/chain-net/dap_stream_ch_chain_net.c
@@ -299,7 +299,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
l_err_str,sizeof (l_err_str));
dap_stream_ch_set_ready_to_write_unsafe(a_ch, true);
} else {
- dap_chain_node_addr_t *l_addr_new = dap_chain_node_gen_addr(l_ch_chain_net_pkt->hdr.net_id);
+ dap_chain_node_addr_t *l_addr_new = dap_chain_node_gen_addr(l_net->pub.id);
dap_stream_ch_chain_net_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_ADDR_LEASE ,
l_ch_chain_net_pkt->hdr.net_id, l_addr_new, sizeof (*l_addr_new));
dap_stream_ch_set_ready_to_write_unsafe(a_ch, true);
diff --git a/modules/channel/chain/CMakeLists.txt b/modules/channel/chain/CMakeLists.txt
index e5a850a5c789c625579eae5b7a10a7b34a78f699..c6aaf1368597bfeeab4ed58d09dd1d347a4117fa 100644
--- a/modules/channel/chain/CMakeLists.txt
+++ b/modules/channel/chain/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_stream_ch_chain)
file(GLOB DAP_STREAM_CH_CHAIN_SRCS *.c)
diff --git a/modules/channel/chain/dap_stream_ch_chain.c b/modules/channel/chain/dap_stream_ch_chain.c
index 006c0cbc372571a976aabc7167a90de6b342fdde..31e1601111f9a0744555e8572226e3c152611de9 100644
--- a/modules/channel/chain/dap_stream_ch_chain.c
+++ b/modules/channel/chain/dap_stream_ch_chain.c
@@ -308,6 +308,7 @@ static bool s_sync_out_chains_proc_callback(dap_proc_thread_t *a_thread, void *a
return true;
}
+
/**
* @brief s_sync_out_gdb_first_gdb_worker_callback
* @param a_worker
@@ -478,7 +479,7 @@ static bool s_sync_in_chains_callback(dap_proc_thread_t *a_thread, void *a_arg)
uint64_t l_atom_copy_size = l_pkt_item->pkt_data_size;
dap_hash_fast(l_atom_copy, l_atom_copy_size, &l_atom_hash);
size_t l_atom_size = 0;
- if (dap_chain_get_atom_by_hash(l_chain, &l_atom_hash, &l_atom_size, l_sync_request->request_hdr.cell_id)) {
+ if (dap_chain_get_atom_by_hash(l_chain, &l_atom_hash, &l_atom_size)) {
if (s_debug_more){
char l_atom_hash_str[72] = {'\0'};
dap_chain_hash_fast_to_str(&l_atom_hash,l_atom_hash_str,sizeof (l_atom_hash_str)-1 );
diff --git a/modules/common/CMakeLists.txt b/modules/common/CMakeLists.txt
index 7689148fe4e70b39da308ebeb5a88cb3f1bc875b..785170c91815e8a9ec72df3d1f8ac5c68e588a7b 100644
--- a/modules/common/CMakeLists.txt
+++ b/modules/common/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_common)
file(GLOB DAP_CHAIN_COMMON_SRCS *.c)
diff --git a/modules/common/dap_chain_common.c b/modules/common/dap_chain_common.c
index 0a1409b07a81529c0e8b9c40a06aaff3c7cadb93..a0a9fafc2dc013ed513110a7994380d9e48e0355 100644
--- a/modules/common/dap_chain_common.c
+++ b/modules/common/dap_chain_common.c
@@ -58,43 +58,6 @@ size_t dap_chain_hash_slow_to_str( dap_chain_hash_slow_t *a_hash, char *a_str, s
return strlen(a_str);
}
-/**
- * @brief dap_chain_hash_fast_to_str
- * @param a_hash
- * @param a_str
- * @param a_str_max
- * @return
- */
-#if 0
-size_t dap_chain_hash_fast_to_str( dap_chain_hash_fast_t *a_hash, char *a_str, size_t a_str_max )
-{
- const size_t c_hash_str_size = sizeof(*a_hash) * 2 + 1 /*trailing zero*/+ 2 /* heading 0x */;
-
- if ( a_str_max < c_hash_str_size ) {
- log_it( L_ERROR, "String for hash too small, need %u but have only %u", c_hash_str_size, a_str_max );
- }
-
-// size_t i;
- // faster conversion to string
-
- dap_snprintf( a_str, 3, "0x" );
-
- size_t l_ret = dap_bin2hex(a_str + 2, a_hash->raw, sizeof(a_hash->raw));
-
- //for(i = 0; i < sizeof(a_hash->raw); ++i)
- // dap_snprintf(a_str + i * 2 + 2, 3, "%02x", (a_hash->raw[i]));
-
- a_str[c_hash_str_size - 1] = '\0';
-
- if(!l_ret)
- return 0;
-
- return c_hash_str_size - 1; //strlen(a_str);
-}
-#endif
-
-
-
/**
* @brief dap_chain_addr_to_str
* @param a_addr
@@ -146,38 +109,10 @@ dap_chain_net_id_t dap_chain_net_id_from_str(const char * a_net_str)
log_it(L_DEBUG, "net id: %s", a_net_str);
a_net_str += 2;
- /*size_t l_net_str_len = strlen( a_net_str);
- if (l_net_str_len >2){
- a_net_str+=2;
- l_net_str_len-=2;
- if (l_net_str_len == sizeof (l_ret)/2 ){
- size_t l_pos =0;
- char l_byte[3];
- while(l_net_str_len){
- // Copy two characters for bytes
- memcpy(l_byte,a_net_str,2);
- l_byte[2]='\0';
- // Read byte chars
- if ( sscanf(l_byte,"%02hhx",&l_ret.raw[l_pos] ) != 1)
- if( sscanf(l_byte,"%02hhX",&l_ret.raw[l_pos] ) ==1 )
- break;
-
- // Update pos
- l_pos++;
- // Reduce in two steps to not to break if input will have bad input
- l_net_str_len-=1;
- if(l_net_str_len)
- l_net_str_len-=1;
- }
- }else
- log_it(L_WARNING,"Wrong input string \"%s\" not recognized as network id", a_net_str);
- } */
-
- if (!(l_ret.uint64 = strtol(a_net_str, NULL, 0))) {
+ if (!(l_ret.uint64 = strtoll(a_net_str, NULL, 0))) {
log_it(L_ERROR, "Wrong input string \"%s\" not recognized as network id", a_net_str);
return l_ret;
}
- //dap_stpcpy(&l_ret.raw, a_net_str);
return l_ret;
}
@@ -282,15 +217,6 @@ int dap_chain_addr_check_sum(const dap_chain_addr_t *a_addr)
return -1;
}
-// 256
-uint128_t dap_chain_uint128_from_uint256(uint256_t a_from)
-{
- if ( !( EQUAL_128(a_from.hi, uint128_0) ) ) {
- log_it(L_ERROR, "Can't convert to uint128_t. It's too big.");
- }
- return a_from.lo;
-}
-
uint64_t dap_chain_uint128_to(uint128_t a_from)
{
#ifdef DAP_GLOBAL_IS_INT128
@@ -306,22 +232,32 @@ uint64_t dap_chain_uint128_to(uint128_t a_from)
#endif
}
-// 256
uint64_t dap_chain_uint256_to(uint256_t a_from)
{
- return dap_chain_uint128_to(a_from.lo);
+#ifdef DAP_GLOBAL_IS_INT128
+ if (a_from.hi || a_from.lo > UINT64_MAX) {
+ log_it(L_ERROR, "Can't convert balance to uint64_t. It's too big.");
+ }
+ return (uint64_t)a_from.lo;
+#else
+ if (!IS_ZERO_128(a_from.hi) || a_from.lo.hi {
+ log_it(L_ERROR, "Can't convert balance to uint64_t. It's too big.");
+ }
+ return a_from.lo.lo;
+#endif
}
-// for tests
-char *dap_chain_u256tostr(uint256_t v_256)
+// 256
+uint128_t dap_chain_uint128_from_uint256(uint256_t a_from)
{
- //char *dest = malloc(130 * sizeof(char));
- //return strcpy(dest, dap_utoa128((char[130]){}, dap_chain_uint128_from_uint256(v_256), 10));
- return dap_chain_balance_print(dap_chain_uint128_from_uint256(v_256));
+ if ( !( EQUAL_128(a_from.hi, uint128_0) ) ) {
+ log_it(L_ERROR, "Can't convert to uint128_t. It's too big.");
+ }
+ return a_from.lo;
}
-char *dap_chain_balance_print(uint128_t a_balance)
+char *dap_chain_balance_print128(uint128_t a_balance)
{
char *l_buf = DAP_NEW_Z_SIZE(char, DATOSHI_POW + 3);
int l_pos = 0;
@@ -358,9 +294,15 @@ char *dap_chain_balance_print(uint128_t a_balance)
return l_buf;
}
-char *dap_chain_balance_to_coins(uint128_t a_balance)
+char *dap_chain_balance_print(uint256_t a_balance)
{
- char *l_buf = dap_chain_balance_print(a_balance);
+ return dap_chain_balance_print128(a_balance.lo);
+}
+
+
+char *dap_chain_balance_to_coins128(uint128_t a_balance)
+{
+ char *l_buf = dap_chain_balance_print128(a_balance);
int l_strlen = strlen(l_buf);
int l_pos;
if (l_strlen > DATOSHI_DEGREE) {
@@ -378,6 +320,11 @@ char *dap_chain_balance_to_coins(uint128_t a_balance)
return l_buf;
}
+char *dap_chain_balance_to_coins(uint256_t a_balance)
+{
+ return dap_chain_balance_to_coins128(a_balance.lo);
+}
+
const union { uint64_t u64[2]; uint32_t u32[4]; } DAP_ALIGN_PACKED c_pow10[DATOSHI_POW + 1] = {
{ .u64 = {0, 1ULL} }, // 0
{ .u64 = {0, 10ULL} }, // 1
@@ -420,7 +367,7 @@ const union { uint64_t u64[2]; uint32_t u32[4]; } DAP_ALIGN_PACKED c_pow10[DATOS
{ .u64 = {5421010862427522170ULL, 687399551400673280ULL} } // 38
};
-uint128_t dap_chain_balance_scan(char *a_balance)
+uint128_t dap_chain_balance_scan128(const char *a_balance)
{
int l_strlen = strlen(a_balance);
uint128_t l_ret = uint128_0, l_nul = uint128_0;
@@ -477,7 +424,13 @@ uint128_t dap_chain_balance_scan(char *a_balance)
return l_ret;
}
-uint128_t dap_chain_coins_to_balance(char *a_coins)
+uint256_t dap_chain_balance_scan(const char *a_balance)
+{
+ return GET_256_FROM_128(dap_chain_balance_scan128(a_balance));
+}
+
+
+uint128_t dap_chain_coins_to_balance128(const char *a_coins)
{
uint128_t l_ret = uint128_0, l_nul = uint128_0;
if (strlen(a_coins) > DATOSHI_POW + 2) {
@@ -513,8 +466,12 @@ uint128_t dap_chain_coins_to_balance(char *a_coins)
l_buf[l_pos + i] = '0';
}
l_buf[l_pos + i] = '\0';
- l_ret = dap_chain_balance_scan(l_buf);
+ l_ret = dap_chain_balance_scan128(l_buf);
DAP_DELETE(l_buf);
return l_ret;
}
+uint256_t dap_chain_coins_to_balance(const char *a_coins)
+{
+ return GET_256_FROM_128(dap_chain_coins_to_balance128(a_coins));
+}
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index dd1da5ab30a840b70b5420351882fb55520b175d..1263cd4bac58ed4f6db4b77c46f3d59e8e94fa5d 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -61,12 +61,11 @@ const char *c_dap_chain_datum_token_flag_str[] = {
* @param a_token_size
* @return
*/
-dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, size_t a_token_size)
+dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t *a_token, size_t a_token_size)
{
// Check if token type could have tsd section
- size_t l_hdr_size = sizeof(*a_token);
size_t l_tsd_size;
-
+ size_t l_hdr_size = sizeof(dap_chain_datum_token_old_t);
if (l_hdr_size > a_token_size){
log_it(L_WARNING, "Token size smaller then header, corrupted data");
return NULL;
@@ -74,13 +73,15 @@ dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, size
switch( a_token->type){
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
+ l_hdr_size = sizeof(dap_chain_datum_token_t);
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
l_tsd_size = a_token->header_private_decl.tsd_total_size;
- break;
+ break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
+ l_hdr_size = sizeof(dap_chain_datum_token_t);
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
l_tsd_size = a_token->header_private_update.tsd_total_size;
- break;
+ break;
default: return NULL;
}
@@ -117,7 +118,8 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(byte_t *a_token_serial, size
memcpy(l_token_old, a_token_serial, (*a_token_size));
size_t l_token_size = (*a_token_size) - sizeof(*l_token_old) + sizeof(dap_chain_datum_token_t);
dap_chain_datum_token_t * l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
- strncpy(l_token->ticker, l_token_old->ticker, sizeof(l_token_old->ticker) );
+ memcpy(l_token->ticker, l_token_old->ticker, sizeof(l_token_old->ticker));
+ l_token->ticker[sizeof(l_token_old->ticker) - 1] = '\0';
size_t l_token_tsd_size = (*a_token_size) - sizeof(*l_token_old);
memcpy(l_token->data_n_tsd, l_token_old->data_n_tsd, l_token_tsd_size);
@@ -229,15 +231,18 @@ dap_sign_t ** dap_chain_datum_token_simple_signs_parse(dap_chain_datum_token_t *
assert(a_datum_token);
assert(a_signs_total);
assert(a_signs_valid);
- assert( a_datum_token_size >= sizeof (a_datum_token));
+ assert(a_datum_token_size >= sizeof(dap_chain_datum_token_old_t));
dap_sign_t ** l_ret = DAP_NEW_Z_SIZE(dap_sign_t*, sizeof (dap_sign_t*)*a_datum_token->header_private.signs_total );
*a_signs_total=0;
*a_signs_valid = a_datum_token->header_private.signs_valid;
size_t l_offset = 0;
uint16_t n = 0;
+ size_t l_signs_offset = a_datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE
+ ? sizeof(dap_chain_datum_token_old_t)
+ : sizeof(dap_chain_datum_token_t);
- while( l_offset < (a_datum_token_size-sizeof (a_datum_token) ) && n < a_datum_token->header_private.signs_total ) {
- dap_sign_t *l_sign = (dap_sign_t *) ( a_datum_token->data_n_tsd + l_offset);
+ while( l_offset < (a_datum_token_size - l_signs_offset) && n < a_datum_token->header_private.signs_total ) {
+ dap_sign_t *l_sign = (dap_sign_t *)((byte_t *)a_datum_token + l_signs_offset + l_offset);
size_t l_sign_size = dap_sign_get_size(l_sign);
if(!l_sign_size ){
log_it(L_WARNING,"Corrupted signature: size is zero");
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 7cb301e07ef4e52224811c88d729e213e4b10a9b..ef4b6934d2219b23a8389f909f6f64a49f689651 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -104,34 +104,14 @@ int dap_chain_datum_tx_add_in_item(dap_chain_datum_tx_t **a_tx, dap_chain_hash_f
*
* return summary value from inserted items
*/
-uint64_t dap_chain_datum_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, dap_list_t *a_list_used_out)
+uint256_t dap_chain_datum_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, dap_list_t *a_list_used_out)
{
dap_list_t *l_list_tmp = a_list_used_out;
- uint64_t l_value_to_items = 0; // how many datoshi to transfer
+ uint256_t l_value_to_items = {}; // how many datoshi to transfer
while (l_list_tmp) {
- list_used_item_t *item = l_list_tmp->data;
- if (dap_chain_datum_tx_add_in_item(a_tx, &item->tx_hash_fast, item->num_idx_out) == 1) {
- l_value_to_items += item->value;
- }
- l_list_tmp = dap_list_next(l_list_tmp);
- }
- return l_value_to_items;
-}
-
-// 256
-uint256_t dap_chain_datum_256_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, dap_list_t *a_list_used_out)
-{
- dap_list_t *l_list_tmp = a_list_used_out;
- uint256_t l_value_to_items = uint256_0; // how many datoshi to transfer
- while (l_list_tmp) {
- list_used_item_256_t *item = l_list_tmp->data;
- if (dap_chain_datum_tx_add_in_item(a_tx, &item->tx_hash_fast, item->num_idx_out) == 1) {
- //l_value_to_items += item->value;
- int overflow_flag = SUM_256_256(l_value_to_items, item->value, &l_value_to_items);
- if ( overflow_flag > 0 ) {
- log_it(L_ERROR,"overflow sum 256 256");
- }
-
+ list_used_item_t *l_item = l_list_tmp->data;
+ if (dap_chain_datum_tx_add_in_item(a_tx, &l_item->tx_hash_fast, l_item->num_idx_out) == 1) {
+ SUM_256_256(l_value_to_items, l_item->value, &l_value_to_items);
}
l_list_tmp = dap_list_next(l_list_tmp);
}
@@ -139,7 +119,6 @@ uint256_t dap_chain_datum_256_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, d
}
-
/**
* @brief dap_chain_datum_tx_add_in_cond_item
* @param a_tx
@@ -168,21 +147,9 @@ int dap_chain_datum_tx_add_in_cond_item(dap_chain_datum_tx_t **a_tx, dap_chain_h
*
* return 1 Ok, -1 Error
*/
-int dap_chain_datum_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint64_t a_value)
-{
- dap_chain_tx_out_t *l_tx_out = dap_chain_datum_tx_item_out_create(a_addr, a_value);
- if(l_tx_out) {
- dap_chain_datum_tx_add_item(a_tx, (const uint8_t *)l_tx_out);
- DAP_DELETE(l_tx_out);
- return 1;
- }
- return -1;
-}
-
-// 256
-int dap_chain_datum_256_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value)
+int dap_chain_datum_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value)
{
- dap_chain_256_tx_out_t *l_tx_out = dap_chain_datum_tx_item_256_out_create(a_addr, a_value);
+ dap_chain_256_tx_out_t *l_tx_out = dap_chain_datum_tx_item_out_create(a_addr, a_value);
if(l_tx_out) {
dap_chain_datum_tx_add_item(a_tx, (const uint8_t *)l_tx_out);
DAP_DELETE(l_tx_out);
@@ -196,7 +163,7 @@ int dap_chain_datum_256_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_c
*
* return 1 Ok, -1 Error
*/
-int dap_chain_datum_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint64_t a_value, const char *a_token)
+int dap_chain_datum_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
{
dap_chain_tx_out_ext_t *l_tx_out = dap_chain_datum_tx_item_out_ext_create(a_addr, a_value, a_token);
if(l_tx_out) {
@@ -207,40 +174,15 @@ int dap_chain_datum_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_c
return -1;
}
-// 256
-int dap_chain_datum_256_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
-{
- dap_chain_256_tx_out_ext_t *l_tx_out = dap_chain_datum_tx_item_256_out_ext_create(a_addr, a_value, a_token);
- if(l_tx_out) {
- dap_chain_datum_tx_add_item(a_tx, (const uint8_t *)l_tx_out);
- DAP_DELETE(l_tx_out);
- return 1;
- }
- return -1;
-}
/**
* Create 'out_cond' item and insert to transaction
*
* return 1 Ok, -1 Error
*/
int dap_chain_datum_tx_add_out_cond_item(dap_chain_datum_tx_t **a_tx, dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
- uint64_t a_value, uint64_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit, const void *a_cond, size_t a_cond_size)
-{
- dap_chain_tx_out_cond_t *l_tx_out = dap_chain_datum_tx_item_out_cond_create_srv_pay(
- a_key, a_srv_uid,a_value, a_value_max_per_unit, a_unit, a_cond, a_cond_size );
- if(l_tx_out) {
- dap_chain_datum_tx_add_item(a_tx, (const uint8_t *) l_tx_out);
- DAP_DELETE(l_tx_out);
- return 1;
- }
- return -1;
-}
-
-// 256
-int dap_chain_datum_256_tx_add_out_cond_item(dap_chain_datum_tx_t **a_tx, dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
uint256_t a_value, uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit, const void *a_cond, size_t a_cond_size)
{
- dap_chain_256_tx_out_cond_t *l_tx_out = dap_chain_datum_tx_item_256_out_cond_create_srv_pay(
+ dap_chain_tx_out_cond_t *l_tx_out = dap_chain_datum_tx_item_out_cond_create_srv_pay(
a_key, a_srv_uid,a_value, a_value_max_per_unit, a_unit, a_cond, a_cond_size );
if(l_tx_out) {
dap_chain_datum_tx_add_item(a_tx, (const uint8_t *) l_tx_out);
diff --git a/modules/common/dap_chain_datum_tx_items.c b/modules/common/dap_chain_datum_tx_items.c
index 59b64a3aeec1a30a13928e545a209f7de3d69820..bf418dedec23cde728554304a1779afc8c511a65 100644
--- a/modules/common/dap_chain_datum_tx_items.c
+++ b/modules/common/dap_chain_datum_tx_items.c
@@ -66,6 +66,7 @@ static size_t dap_chain_256_tx_out_get_size(const dap_chain_256_tx_out_t *a_item
return size;
}
+// 256
static size_t dap_chain_tx_out_ext_get_size(const dap_chain_tx_out_ext_t *a_item)
{
(void) a_item;
@@ -73,26 +74,11 @@ static size_t dap_chain_tx_out_ext_get_size(const dap_chain_tx_out_ext_t *a_item
return size;
}
-// 256
-static size_t dap_chain_256_tx_out_ext_get_size(const dap_chain_256_tx_out_ext_t *a_item)
-{
- (void) a_item;
- size_t size = sizeof(dap_chain_256_tx_out_ext_t);
- return size;
-}
-
static size_t dap_chain_tx_out_cond_get_size(const dap_chain_tx_out_cond_t *a_item)
{
return sizeof(dap_chain_tx_out_cond_t) + a_item->params_size;
}
-// 256
-static size_t dap_chain_256_tx_out_cond_get_size(const dap_chain_256_tx_out_cond_t *a_item)
-{
- return sizeof(dap_chain_256_tx_out_cond_t) + a_item->params_size;
-}
-
-
static size_t dap_chain_tx_pkey_get_size(const dap_chain_tx_pkey_t *a_item)
{
size_t size = sizeof(dap_chain_tx_pkey_t) + a_item->header.sig_size;
@@ -140,29 +126,22 @@ size_t dap_chain_datum_item_tx_get_size(const uint8_t *a_item)
case TX_ITEM_TYPE_OUT: // Transaction outputs
size = dap_chain_tx_out_get_size((const dap_chain_tx_out_t*) a_item);
break;
- case TX_ITEM_TYPE_256_OUT: // 256
+ case TX_ITEM_TYPE_OUT_256: // 256
size = dap_chain_256_tx_out_get_size((const dap_chain_256_tx_out_t*) a_item);
break;
- case TX_ITEM_TYPE_OUT_EXT:
+ case TX_ITEM_TYPE_OUT_EXT: // Exchange transaction outputs
size = dap_chain_tx_out_ext_get_size((const dap_chain_tx_out_ext_t*) a_item);
break;
- case TX_ITEM_TYPE_256_OUT_EXT: // 256
- size = dap_chain_256_tx_out_ext_get_size((const dap_chain_256_tx_out_ext_t*) a_item);
- break;
case TX_ITEM_TYPE_RECEIPT: // Receipt
size = dap_chain_datum_tx_receipt_get_size((const dap_chain_datum_tx_receipt_t*) a_item);
- break;
- case TX_ITEM_TYPE_256_RECEIPT: // 256
- size = dap_chain_datum_tx_receipt_get_size((const dap_chain_datum_tx_receipt_t*) a_item);
- break;
case TX_ITEM_TYPE_IN_COND: // Transaction inputs with condition
size = dap_chain_tx_in_cond_get_size((const dap_chain_tx_in_cond_t*) a_item);
break;
case TX_ITEM_TYPE_OUT_COND: // Transaction output with condition
- size = dap_chain_tx_out_cond_get_size((const dap_chain_tx_out_cond_t*) a_item);
+ size = 0; // obsolete dap_chain_tx_out_cond_get_size((const dap_chain_tx_out_cond_t*) a_item);
break;
- case TX_ITEM_TYPE_256_OUT_COND: // 256
- size = dap_chain_256_tx_out_cond_get_size((const dap_chain_256_tx_out_cond_t*) a_item);
+ case TX_ITEM_TYPE_OUT_256_COND: // 256
+ size = dap_chain_tx_out_cond_get_size((const dap_chain_tx_out_cond_t *)a_item);
break;
case TX_ITEM_TYPE_PKEY: // Transaction public keys
size = dap_chain_tx_pkey_get_size((const dap_chain_tx_pkey_t*) a_item);
@@ -173,9 +152,6 @@ size_t dap_chain_datum_item_tx_get_size(const uint8_t *a_item)
case TX_ITEM_TYPE_TOKEN: // token item
size = dap_chain_tx_token_get_size((const dap_chain_tx_token_t*) a_item);
break;
- case TX_ITEM_TYPE_256_TOKEN: // token item
- size = dap_chain_tx_token_get_size((const dap_chain_tx_token_t*) a_item);
- break;
default:
return 0;
}
@@ -197,17 +173,6 @@ dap_chain_tx_token_t* dap_chain_datum_tx_item_token_create(dap_chain_hash_fast_t
strncpy(l_item->header.ticker, a_ticker, sizeof(l_item->header.ticker) - 1);
return l_item;
}
-// 256
-dap_chain_tx_token_t* dap_chain_datum_tx_item_256_token_create(dap_chain_hash_fast_t * a_datum_token_hash,const char * a_ticker)
-{
- if(!a_ticker)
- return NULL;
- dap_chain_tx_token_t *l_item = DAP_NEW_Z(dap_chain_tx_token_t);
- l_item->header.type = TX_ITEM_TYPE_256_TOKEN;
- memcpy (& l_item->header.token_emission_hash, a_datum_token_hash, sizeof ( *a_datum_token_hash ) );
- strncpy(l_item->header.ticker, a_ticker, sizeof(l_item->header.ticker) - 1);
- return l_item;
-}
/**
* Create item dap_chain_tx_out_t
@@ -250,30 +215,18 @@ dap_chain_tx_in_cond_t* dap_chain_datum_tx_item_in_cond_create(dap_chain_hash_fa
*
* return item, NULL Error
*/
-dap_chain_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a_addr, uint64_t a_value)
-{
- if(!a_addr)
- return NULL;
- dap_chain_tx_out_t *l_item = DAP_NEW_Z(dap_chain_tx_out_t);
- l_item->header.type = TX_ITEM_TYPE_OUT;
- l_item->header.value = a_value;
- memcpy(&l_item->addr, a_addr, sizeof(dap_chain_addr_t));
- return l_item;
-}
-
-//256
-dap_chain_256_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value)
+dap_chain_256_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value)
{
if(!a_addr)
return NULL;
dap_chain_256_tx_out_t *l_item = DAP_NEW_Z(dap_chain_256_tx_out_t);
- l_item->header.type = TX_ITEM_TYPE_256_OUT;
+ l_item->header.type = TX_ITEM_TYPE_OUT_256;
l_item->header.value = a_value;
memcpy(&l_item->addr, a_addr, sizeof(dap_chain_addr_t));
return l_item;
}
-dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_addr_t *a_addr, uint64_t a_value, const char *a_token)
+dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
{
if (!a_addr || !a_token)
return NULL;
@@ -285,28 +238,15 @@ dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_a
return l_item;
}
-//256
-dap_chain_256_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
-{
- if (!a_addr || !a_token)
- return NULL;
- dap_chain_256_tx_out_ext_t *l_item = DAP_NEW_Z(dap_chain_256_tx_out_ext_t);
- l_item->header.type = TX_ITEM_TYPE_256_OUT_EXT;
- l_item->header.value = a_value;
- memcpy(&l_item->addr, a_addr, sizeof(dap_chain_addr_t));
- strcpy(l_item->token, a_token);
- return l_item;
-}
-
-
/**
* Create item dap_chain_tx_out_cond_t
*
* return item, NULL Error
*/
dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
- uint64_t a_value,uint64_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
- const void *a_params, size_t a_params_size)
+ uint256_t a_value, uint256_t a_value_max_per_unit,
+ dap_chain_net_srv_price_unit_uid_t a_unit,
+ const void *a_params, size_t a_params_size)
{
if(!a_key || !a_params)
return NULL;
@@ -318,7 +258,7 @@ dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_pay(dap_enc
if(l_item == NULL)
return NULL;
- l_item->header.item_type = TX_ITEM_TYPE_OUT_COND;
+ l_item->header.item_type = TX_ITEM_TYPE_OUT_256_COND;
l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY; // By default creatre cond for service pay. Rework with smth more flexible
l_item->subtype.srv_pay.srv_uid = a_srv_uid;
@@ -330,66 +270,15 @@ dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_pay(dap_enc
return l_item;
}
-// 256
-dap_chain_256_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
- uint256_t a_value,uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
- const void *a_params, size_t a_params_size)
-{
- if(!a_key || !a_params)
- return NULL;
- size_t l_pub_key_size = 0;
- uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_key, &l_pub_key_size);
-
-
- dap_chain_256_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_256_tx_out_cond_t, sizeof(dap_chain_256_tx_out_cond_t) + a_params_size);
- if(l_item == NULL)
- return NULL;
-
- l_item->header.item_type = TX_ITEM_TYPE_256_OUT_COND;
- l_item->header.value = a_value;
- l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY; // By default creatre cond for service pay. Rework with smth more flexible
- l_item->subtype.srv_pay.srv_uid = a_srv_uid;
- l_item->subtype.srv_pay.unit = a_unit;
- l_item->subtype.srv_pay.unit_price_max_datoshi = a_value_max_per_unit;
- dap_hash_fast( l_pub_key, l_pub_key_size, & l_item->subtype.srv_pay.pkey_hash);
- l_item->params_size = (uint32_t)a_params_size;
- memcpy(l_item->params, a_params, a_params_size);
- return l_item;
-}
-
-
-
dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid, dap_chain_net_id_t a_net_id,
- const char *a_token, uint64_t a_value,
- const void *a_params, uint32_t a_params_size)
-{
- if (!a_token) {
- return NULL;
- }
- dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, sizeof(dap_chain_tx_out_cond_t) + a_params_size);
- l_item->header.item_type = TX_ITEM_TYPE_OUT_COND;
- l_item->header.value = a_value;
- l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE;
- l_item->subtype.srv_xchange.srv_uid = a_srv_uid;
- l_item->subtype.srv_xchange.net_id = a_net_id;
- strcpy(l_item->subtype.srv_xchange.token, a_token);
- l_item->params_size = a_params_size;
- if (a_params_size) {
- memcpy(l_item->params, a_params, a_params_size);
- }
- return l_item;
-}
-
-// 256
-dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid, dap_chain_net_id_t a_net_id,
const char *a_token, uint256_t a_value,
const void *a_params, uint32_t a_params_size)
{
if (!a_token) {
return NULL;
}
- dap_chain_256_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_256_tx_out_cond_t, sizeof(dap_chain_256_tx_out_cond_t) + a_params_size);
- l_item->header.item_type = TX_ITEM_TYPE_256_OUT_COND;
+ dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, sizeof(dap_chain_tx_out_cond_t) + a_params_size);
+ l_item->header.item_type = TX_ITEM_TYPE_OUT_256_COND;
l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE;
l_item->subtype.srv_xchange.srv_uid = a_srv_uid;
@@ -402,12 +291,12 @@ dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_xch
return l_item;
}
-dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value, long double a_fee_value,
+dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
const void *a_params, uint32_t a_params_size)
{
dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, sizeof(dap_chain_tx_out_cond_t) + a_params_size);
- l_item->header.item_type = TX_ITEM_TYPE_OUT_COND;
+ l_item->header.item_type = TX_ITEM_TYPE_OUT_256_COND;
l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE;
l_item->subtype.srv_stake.srv_uid = a_srv_uid;
@@ -421,27 +310,6 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_c
return l_item;
}
-// 256
-dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
- dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
- const void *a_params, uint32_t a_params_size)
-{
- dap_chain_256_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_256_tx_out_cond_t, sizeof(dap_chain_256_tx_out_cond_t) + a_params_size);
- l_item->header.item_type = TX_ITEM_TYPE_256_OUT_COND;
- l_item->header.value = a_value;
- l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE;
- l_item->subtype.srv_stake.srv_uid = a_srv_uid;
- l_item->subtype.srv_stake.fee_value = a_fee_value;
- memcpy(&l_item->subtype.srv_stake.fee_addr, a_fee_addr, sizeof(dap_chain_addr_t));
- memcpy(&l_item->subtype.srv_stake.hldr_addr, a_hldr_addr, sizeof(dap_chain_addr_t));
- l_item->params_size = a_params_size;
- if (a_params_size) {
- memcpy(l_item->params, a_params, a_params_size);
- }
- return l_item;
-}
-
-
/**
* Create item dap_chain_tx_sig_t
*
@@ -505,11 +373,7 @@ uint8_t* dap_chain_datum_tx_item_get( dap_chain_datum_tx_t *a_tx, int *a_item_id
if (a_type == TX_ITEM_TYPE_ANY || a_type == l_type ||
(a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_OUT) ||
(a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_OUT_COND) ||
- (a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_OUT_EXT) ||
- (a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_256_OUT) ||
- (a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_256_OUT_COND) ||
- (a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_256_OUT_EXT)
- ) {
+ (a_type == TX_ITEM_TYPE_OUT_ALL && l_type == TX_ITEM_TYPE_OUT_EXT)) {
if(a_item_idx_start)
*a_item_idx_start = l_item_idx;
if(a_item_out_size)
@@ -567,24 +431,3 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a
}
return l_res;
}
-
-// 256
-dap_chain_256_tx_out_cond_t *dap_chain_datum_256_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num)
-{
- dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
- int l_prev_cond_idx = l_list_out_items ? 0 : -1;
- dap_chain_256_tx_out_cond_t *l_res = NULL;
- for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_prev_cond_idx++) {
- if (*(uint8_t *)l_list_tmp->data == TX_ITEM_TYPE_256_OUT_COND) {
- l_res = l_list_tmp->data;
- break;
- }
- }
- dap_list_free(l_list_out_items);
- if (a_out_num) {
- *a_out_num = l_prev_cond_idx;
- }
- return l_res;
-}
-
-
diff --git a/modules/common/dap_chain_datum_tx_receipt.c b/modules/common/dap_chain_datum_tx_receipt.c
index 66a4712322fd4b8f769fde168e5bcc57ae2dc96e..5e374016d46fb98952c1f535ecbcfd39b89d64bf 100644
--- a/modules/common/dap_chain_datum_tx_receipt.c
+++ b/modules/common/dap_chain_datum_tx_receipt.c
@@ -42,7 +42,7 @@
*/
dap_chain_datum_tx_receipt_t * dap_chain_datum_tx_receipt_create( dap_chain_net_srv_uid_t a_srv_uid,
dap_chain_net_srv_price_unit_uid_t a_units_type,
- uint64_t a_units, uint64_t a_value_datoshi,
+ uint64_t a_units, uint256_t a_value_datoshi,
const void * a_ext, size_t a_ext_size)
{
dap_chain_datum_tx_receipt_t * l_ret = DAP_NEW_Z_SIZE(dap_chain_datum_tx_receipt_t, dap_chain_datum_tx_receipt_get_size_hdr() +a_ext_size );
@@ -60,27 +60,6 @@ dap_chain_datum_tx_receipt_t * dap_chain_datum_tx_receipt_create( dap_chain_net_
return l_ret;
}
-// 256
-dap_chain_datum_tx_receipt_t * dap_chain_datum_256_tx_receipt_create( dap_chain_net_srv_uid_t a_srv_uid,
- dap_chain_net_srv_price_unit_uid_t a_units_type,
- uint64_t a_units, uint256_t a_value_datoshi,
- const void * a_ext, size_t a_ext_size)
-{
- dap_chain_datum_tx_receipt_t * l_ret = DAP_NEW_Z_SIZE(dap_chain_datum_tx_receipt_t, dap_chain_datum_tx_receipt_get_size_hdr() +a_ext_size );
- l_ret->type = TX_ITEM_TYPE_256_RECEIPT;
- l_ret->receipt_info.units_type = a_units_type;
- l_ret->receipt_info.srv_uid = a_srv_uid;
- l_ret->receipt_info.units = a_units;
- l_ret->receipt_info.value_datoshi_256 = a_value_datoshi;
- l_ret->size = dap_chain_datum_tx_receipt_get_size_hdr()+a_ext_size;
-
- if( a_ext_size && a_ext){
- l_ret->exts_size = a_ext_size;
- memcpy(l_ret->exts_n_signs, a_ext, a_ext_size);
- }
- return l_ret;
-}
-
size_t dap_chain_datum_tx_receipt_sign_add(dap_chain_datum_tx_receipt_t ** a_receipt, size_t a_receipt_size, dap_enc_key_t *a_key )
{
dap_chain_datum_tx_receipt_t *l_receipt = *a_receipt;
@@ -104,7 +83,6 @@ size_t dap_chain_datum_tx_receipt_sign_add(dap_chain_datum_tx_receipt_t ** a_rec
return a_receipt_size;
}
-
/**
* @brief dap_chain_datum_tx_receipt_sign_get
* @param l_receipt
@@ -128,7 +106,6 @@ dap_sign_t* dap_chain_datum_tx_receipt_sign_get(dap_chain_datum_tx_receipt_t * l
return l_sign;
}
-
/**
* @brief dap_chain_datum_tx_receipt_signs_count
* @param a_receipt
diff --git a/modules/common/include/dap_chain_common.h b/modules/common/include/dap_chain_common.h
index 35804fe06bbd42bbb584630708e2d2f0bee58bfb..f0050efad9427c58f7509a063ce310ca2719fab1 100644
--- a/modules/common/include/dap_chain_common.h
+++ b/modules/common/include/dap_chain_common.h
@@ -189,53 +189,38 @@ typedef union {
serv_unit_enum_t enm;
} dap_chain_net_srv_price_unit_uid_t;
-typedef enum dap_chain_tx_item_type {
+enum dap_chain_tx_item_type {
TX_ITEM_TYPE_IN = 0x00, /// @brief Transaction: inputs
TX_ITEM_TYPE_OUT = 0x10, /// @brief Transaction: outputs
TX_ITEM_TYPE_OUT_EXT = 0x11,
- TX_ITEM_TYPE_256_OUT = 0x12, // 256
- TX_ITEM_TYPE_256_OUT_EXT = 0x13, // 256
+ TX_ITEM_TYPE_OUT_256 = 0x12, // 256
TX_ITEM_TYPE_PKEY = 0x20,
TX_ITEM_TYPE_SIG = 0x30,
TX_ITEM_TYPE_TOKEN = 0x40,
TX_ITEM_TYPE_TOKEN_EXT = 0x41,
- TX_ITEM_TYPE_256_TOKEN = 0x42,
- TX_ITEM_TYPE_256_TOKEN_EXT = 0x43,
-
TX_ITEM_TYPE_IN_COND = 0x50, /// @brief Transaction: conditon inputs
- TX_ITEM_TYPE_OUT_COND = 0x60, /// @brief Transaction: conditon outputs
- TX_ITEM_TYPE_256_OUT_COND = 0x61, // 256
+ TX_ITEM_TYPE_OUT_COND = 0x60, // Obsolete
+ TX_ITEM_TYPE_OUT_256_COND = 0x61, /// @brief Transaction: 256 bit conditon outputs
TX_ITEM_TYPE_RECEIPT = 0x70,
- TX_ITEM_TYPE_256_RECEIPT = 0x71,
TX_ITEM_TYPE_OUT_ALL = 0xfe,
TX_ITEM_TYPE_ANY = 0xff
-} dap_chain_tx_item_type_t;
+};
+typedef uint32_t dap_chain_tx_item_type_t;
typedef struct dap_chain_receipt{
dap_chain_net_srv_uid_t srv_uid; // Service UID
dap_chain_net_srv_price_unit_uid_t units_type;
uint64_t units; // Unit of service (seconds, megabytes, etc.) Only for SERV_CLASS_PERMANENT
- union {
- uint64_t value_datoshi; // Receipt value
- uint256_t value_datoshi_256;
- };
+ uint256_t value_datoshi; // Receipt value
} dap_chain_receipt_info_t;
-// 256
-// typedef struct dap_chain_256_receipt{
-// dap_chain_net_srv_uid_t srv_uid; // Service UID
-// dap_chain_net_srv_price_unit_uid_t units_type;
-// uint64_t units; // Unit of service (seconds, megabytes, etc.) Only for SERV_CLASS_PERMANENT
-// uint256_t value_datoshi; // Receipt value
-// } dap_chain_256_receipt_info_t;
-
#ifdef __cplusplus
extern "C" {
#endif
@@ -265,12 +250,6 @@ DAP_STATIC_INLINE uint64_t dap_chain_coins_to_datoshi(long double a_count)
DAP_STATIC_INLINE uint128_t dap_chain_uint128_from(uint64_t a_from)
{
-// #ifdef DAP_GLOBAL_IS_INT128
-// return (uint128_t)a_from;
-// #else
-// uint128_t l_ret = {{ .0, a_from}};
-// return l_ret;
-// #endif
uint128_t l_ret = uint128_0;
ADD_64_INTO_128(a_from, &l_ret );
return l_ret;
@@ -289,17 +268,21 @@ DAP_STATIC_INLINE uint256_t dap_chain_uint256_from(uint64_t a_from)
return l_ret_256;
}
+DAP_STATIC_INLINE uint256_t dap_chain_uint256_from_uint128(uint128_t a_from)
+{
+ uint256_t l_ret_256 = uint256_0;
+ ADD_128_INTO_256(a_from, &l_ret_256);
+ return l_ret_256;
+}
+
uint64_t dap_chain_uint128_to(uint128_t a_from);
// 256
uint64_t dap_chain_uint256_to(uint256_t a_from);
-char *dap_chain_u256tostr(uint256_t v);
-
-
-char *dap_chain_balance_print(uint128_t a_balance);
-char *dap_chain_balance_to_coins(uint128_t a_balance);
-uint128_t dap_chain_balance_scan(char *a_balance);
-uint128_t dap_chain_coins_to_balance(char *a_coins);
+char *dap_chain_balance_print(uint256_t a_balance);
+char *dap_chain_balance_to_coins(uint256_t a_balance);
+uint256_t dap_chain_balance_scan(const char *a_balance);
+uint256_t dap_chain_coins_to_balance(const char *a_coins);
/**
* @brief dap_chain_hash_to_str
diff --git a/modules/common/include/dap_chain_datum.h b/modules/common/include/dap_chain_datum.h
index 042789f2d47e2a2863e822494942eaa774343243..0b112fa6b1eb23f27bcf49693dcaa4294b11d38d 100644
--- a/modules/common/include/dap_chain_datum.h
+++ b/modules/common/include/dap_chain_datum.h
@@ -31,13 +31,12 @@
#define DAP_CHAIN_DATUM_VERSION 0x00
/// End section, means all the rest of the block is empty
-#define DAP_CHAIN_DATUM_BLOCK_END 0x0000
+#define DAP_CHAIN_DATUM_BLOCK_END 0x0000
/// Section with additional roots, for example transaction roots
-#define DAP_CHAIN_DATUM_BLOCK_ROOTS 0x0001
+#define DAP_CHAIN_DATUM_BLOCK_ROOTS 0x0001
/// Transaction header section
#define DAP_CHAIN_DATUM_TX 0x0100
-#define DAP_CHAIN_DATUM_256_TX 0x0101 // 256
/// Transaction request section
#define DAP_CHAIN_DATUM_TX_REQUEST 0x0300
@@ -60,9 +59,7 @@
/// Token
/// Simple token decl
#define DAP_CHAIN_DATUM_TOKEN_DECL 0xf000
-#define DAP_CHAIN_DATUM_256_TOKEN_DECL 0xf001 // 256
#define DAP_CHAIN_DATUM_TOKEN_EMISSION 0xf100
-#define DAP_CHAIN_DATUM_256_TOKEN_EMISSION 0xf101 // 256
#define DAP_CHAIN_DATUM_TOKEN_DISMISSAL 0xf200
#define DAP_CHAIN_DATUM_CUSTOM 0xffff
@@ -71,8 +68,6 @@
switch (t) { \
case DAP_CHAIN_DATUM_TX: \
s = "DATUM_TX"; break; \
- case DAP_CHAIN_DATUM_256_TX: \
- s = "DATUM_256_TX"; break; \
case DAP_CHAIN_DATUM_TX_REQUEST: \
s = "DATUM_WASM_CODE"; break; \
case DAP_CHAIN_DATUM_WASM_CODE: \
@@ -91,12 +86,8 @@
s = "DATUM_CUSTOM"; break; \
case DAP_CHAIN_DATUM_TOKEN_DECL: \
s = "DATUM_TOKEN_DECL"; break; \
- case DAP_CHAIN_DATUM_256_TOKEN_DECL: \
- s = "DATUM_256_TOKEN_DECL"; break; \
case DAP_CHAIN_DATUM_TOKEN_EMISSION:\
s = "DATUM_TOKEN_EMISSION"; break;\
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION:\
- s = "DATUM_256_TOKEN_EMISSION"; break;\
default: \
s = "DATUM_UNKNOWN"; break; \
}
diff --git a/modules/common/include/dap_chain_datum_token.h b/modules/common/include/dap_chain_datum_token.h
index 53939e98082797f9f3514dd14a77aa359875a4b3..a0c717d0ced770686f6768d0d193243bf8deb4ae 100644
--- a/modules/common/include/dap_chain_datum_token.h
+++ b/modules/common/include/dap_chain_datum_token.h
@@ -98,6 +98,7 @@ typedef struct dap_chain_datum_token{
dap_chain_addr_t premine_address;
uint32_t flags;
} DAP_ALIGN_PACKED header_public;
+ byte_t free_space[256]; // For future changes
};
byte_t data_n_tsd[]; // Signs and/or types-size-data sections
} DAP_ALIGN_PACKED dap_chain_datum_token_t;
@@ -114,13 +115,13 @@ typedef struct dap_chain_datum_token{
// 256
// Simple private token decl
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE 0x0005
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE 0x0005
// Extended declaration of privatetoken with in-time control
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL 0x0006
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL 0x0006
// Token update
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE 0x0007
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE 0x0007
// Open token with now ownership
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC 0x0008
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC 0x0008
// Macros for token flags
@@ -267,7 +268,6 @@ typedef struct dap_chain_datum_token_emission{
uint256_t value_256;
};
uint8_t nonce[DAP_CHAIN_DATUM_NONCE_SIZE];
- // bool type_256; // emission 256
} DAP_ALIGN_PACKED hdr;
union {
struct {
@@ -276,10 +276,7 @@ typedef struct dap_chain_datum_token_emission{
uint64_t lock_time;
} DAP_ALIGN_PACKED type_presale;
struct {
- union {
- uint64_t value_start;// Default value. Static if nothing else is defined
- uint256_t value_start_256;
- };
+ uint64_t value_start;// Default value. Static if nothing else is defined
char value_change_algo_codename[32];
} DAP_ALIGN_PACKED type_atom_owner;
struct {
diff --git a/modules/common/include/dap_chain_datum_tx.h b/modules/common/include/dap_chain_datum_tx.h
index 8c569f03caadd77a89d5a11184bba765af8ac22d..c6b9c79f3d4e87c4fa817ab9586eea1d93714067 100644
--- a/modules/common/include/dap_chain_datum_tx.h
+++ b/modules/common/include/dap_chain_datum_tx.h
@@ -79,11 +79,7 @@ int dap_chain_datum_tx_add_item(dap_chain_datum_tx_t **a_tx, const uint8_t *a_it
*
* return summary value from inserted items
*/
-uint64_t dap_chain_datum_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, dap_list_t *a_list_used_out);
-
-// 256
-uint256_t dap_chain_datum_256_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, dap_list_t *a_list_used_out);
-
+uint256_t dap_chain_datum_tx_add_in_item_list(dap_chain_datum_tx_t **a_tx, dap_list_t *a_list_used_out);
/**
* Create 'in' item and insert to transaction
@@ -108,10 +104,7 @@ int dap_chain_datum_tx_add_in_cond_item(dap_chain_datum_tx_t **a_tx, dap_chain_h
*
* return 1 Ok, -1 Error
*/
-int dap_chain_datum_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint64_t a_value);
-
-// 256
-int dap_chain_datum_256_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value);
+int dap_chain_datum_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value);
/**
* Create 'out'_ext item and insert to transaction
@@ -119,10 +112,6 @@ int dap_chain_datum_256_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_c
* return 1 Ok, -1 Error
*/
int dap_chain_datum_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr,
- uint64_t a_value, const char *a_token);
-
-// 256
-int dap_chain_datum_256_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr,
uint256_t a_value, const char *a_token);
/**
@@ -131,10 +120,6 @@ int dap_chain_datum_256_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const d
* return 1 Ok, -1 Error
*/
int dap_chain_datum_tx_add_out_cond_item(dap_chain_datum_tx_t **a_tx, dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
- uint64_t a_value, uint64_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit, const void *a_cond, size_t a_cond_size);
-
-//256
-int dap_chain_datum_256_tx_add_out_cond_item(dap_chain_datum_tx_t **a_tx, dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
uint256_t a_value, uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit, const void *a_cond, size_t a_cond_size);
/**
diff --git a/modules/common/include/dap_chain_datum_tx_in.h b/modules/common/include/dap_chain_datum_tx_in.h
index aabdc298bbaee6eab61d81d83f380e7a4ee1378b..b9fcbc2801aacc75ed0ed7b8dc6f273e8e9cf166 100644
--- a/modules/common/include/dap_chain_datum_tx_in.h
+++ b/modules/common/include/dap_chain_datum_tx_in.h
@@ -34,7 +34,7 @@
typedef struct dap_chain_tx_in{
struct {
- dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
+ dap_chain_tx_item_type_t type; /// @param type @brief Transaction item type
dap_chain_hash_fast_t tx_prev_hash; /// @param tx_prev_hash @brief Hash of the previous transaction. 0 for generation TX
uint32_t tx_out_prev_idx; /// @param tx_prev_idx @brief Previous tx_out index. 0 for generation TX
// dap_sign_type_t sig_type; /// Signature type
@@ -45,18 +45,8 @@ typedef struct dap_chain_tx_in{
} DAP_ALIGN_PACKED dap_chain_tx_in_t;
typedef struct list_used_item {
- dap_chain_hash_fast_t tx_hash_fast;
- uint32_t num_idx_out;
- uint8_t padding[4];
- uint64_t value;
-//dap_chain_tx_out_t *tx_out;
-} list_used_item_t;
-
-// 256
-typedef struct list_used_item_256 {
dap_chain_hash_fast_t tx_hash_fast;
uint32_t num_idx_out;
uint8_t padding[4];
uint256_t value;
-//dap_chain_tx_out_t *tx_out;
-} list_used_item_256_t;
+} list_used_item_t;
diff --git a/modules/common/include/dap_chain_datum_tx_items.h b/modules/common/include/dap_chain_datum_tx_items.h
index 216577aaa75a3bc8307ab9bee6f91d8f10957888..c06d9abd9e1b50a51ad9ff8b3123e2f8a92f087d 100644
--- a/modules/common/include/dap_chain_datum_tx_items.h
+++ b/modules/common/include/dap_chain_datum_tx_items.h
@@ -53,25 +53,19 @@ DAP_STATIC_INLINE const char * dap_chain_datum_tx_item_type_to_str(dap_chain_tx_
switch(a_item_type){
case TX_ITEM_TYPE_IN: return "TX_ITEM_TYPE_IN";
case TX_ITEM_TYPE_OUT: return "TX_ITEM_TYPE_OUT";
- case TX_ITEM_TYPE_256_OUT: return "TX_ITEM_TYPE_256_OUT"; // 256
- case TX_ITEM_TYPE_OUT_EXT: return "TX_ITEM_TYPE_OUT_EXT";
- case TX_ITEM_TYPE_256_OUT_EXT: return "TX_ITEM_TYPE_256_OUT_EXT"; // 256
+ case TX_ITEM_TYPE_OUT_256: return "TX_ITEM_TYPE_OUT_256"; // 256
+ case TX_ITEM_TYPE_OUT_EXT: return "TX_ITEM_TYPE_OUT_EXT"; // 256
case TX_ITEM_TYPE_PKEY: return "TX_ITEM_TYPE_PKEY";
case TX_ITEM_TYPE_SIG: return "TX_ITEM_TYPE_SIG";
case TX_ITEM_TYPE_TOKEN: return "TX_ITEM_TYPE_TOKEN";
- case TX_ITEM_TYPE_256_TOKEN: return "TX_ITEM_TYPE_256_TOKEN"; // 256
case TX_ITEM_TYPE_TOKEN_EXT: return "TX_ITEM_TYPE_TOKEN_EXT";
- case TX_ITEM_TYPE_256_TOKEN_EXT: return "TX_ITEM_TYPE_256_TOKEN_EXT"; // 256
case TX_ITEM_TYPE_IN_COND: return "TX_ITEM_TYPE_IN_COND";
- case TX_ITEM_TYPE_OUT_COND: return "TX_ITEM_TYPE_OUT_COND";
- case TX_ITEM_TYPE_256_OUT_COND: return "TX_ITEM_TYPE_256_OUT_COND"; // 256
+ case TX_ITEM_TYPE_OUT_COND: return "TX_ITEM_TYPE_OUT_COND"; // 256
case TX_ITEM_TYPE_RECEIPT: return "TX_ITEM_TYPE_RECEIPT";
- case TX_ITEM_TYPE_256_RECEIPT: return "TX_ITEM_TYPE_256_RECEIPT"; // 256
case TX_ITEM_TYPE_OUT_ALL: return "TX_ITEM_TYPE_OUT_ALL";
case TX_ITEM_TYPE_ANY: return "TX_ITEM_TYPE_ANY";
default: return "UNDEFINED";
}
-
}
/**
@@ -88,9 +82,6 @@ size_t dap_chain_datum_item_tx_get_size(const uint8_t *a_item);
*/
dap_chain_tx_token_t* dap_chain_datum_tx_item_token_create(dap_chain_hash_fast_t * a_datum_token_hash,const char * a_ticker);
-//256
-dap_chain_tx_token_t* dap_chain_datum_tx_item_256_token_create(dap_chain_hash_fast_t * a_datum_token_hash,const char * a_ticker);
-
/**
* Create item dap_chain_tx_out_t
*
@@ -106,20 +97,14 @@ dap_chain_tx_in_cond_t* dap_chain_datum_tx_item_in_cond_create(dap_chain_hash_fa
*
* return item, NULL Error
*/
-dap_chain_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a_addr, uint64_t a_value);
-
-// 256
-dap_chain_256_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value);
+dap_chain_256_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value);
/**
* Create item dap_chain_tx_out_ext_t
*
* return item, NULL Error
*/
-dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_addr_t *a_addr, uint64_t a_value, const char *a_token);
-
-// 256
-dap_chain_256_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token);
+dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token);
/**
* Create item dap_chain_tx_out_cond_t
@@ -127,51 +112,38 @@ dap_chain_256_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap
* return item, NULL Error
*/
dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
- uint64_t a_value, uint64_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
- const void *a_cond, size_t a_cond_size);
-// 256
-dap_chain_256_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
- uint256_t a_value, uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
- const void *a_cond, size_t a_cond_size);
+ uint256_t a_value, uint256_t a_value_max_per_unit,
+ dap_chain_net_srv_price_unit_uid_t a_unit,
+ const void *a_params, size_t a_params_size);
/**
* Create item dap_chain_tx_out_cond_t for eXchange service
*
* return item, NULL Error
*/
-dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid,
- dap_chain_net_id_t a_net_id, const char *a_token, uint64_t a_value,
- const void *a_params, uint32_t a_params_size);
-//256
-dap_chain_256_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid,
- dap_chain_net_id_t a_net_id, const char *a_token, uint256_t a_value,
- const void *a_params, uint32_t a_params_size);
-
-
+dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid,
+ dap_chain_net_id_t a_net_id, const char *a_token, uint256_t a_value,
+ const void *a_params, uint32_t a_params_size);
/**
* Create item dap_chain_tx_out_cond_t for stake service
*
* return item, NULL Error
*/
-dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value, long double a_fee_value,
- dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
- const void *a_params, uint32_t a_params_size);
-// 256
-dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
- dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
- const void *a_params, uint32_t a_params_size);
+dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
+ dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
+ const void *a_params, uint32_t a_params_size);
/**
* Create item dap_chain_tx_sig_t
*
* return item, NULL Error
*/
-dap_chain_tx_sig_t* dap_chain_datum_tx_item_sign_create(dap_enc_key_t *a_key, const void *a_data, size_t a_data_size);
+dap_chain_tx_sig_t *dap_chain_datum_tx_item_sign_create(dap_enc_key_t *a_key, const void *a_data, size_t a_data_size);
/**
* Get sign from sign item
*
* return sign, NULL Error
*/
-dap_sign_t* dap_chain_datum_tx_item_sign_get_sig(dap_chain_tx_sig_t *a_tx_sig);
+dap_sign_t *dap_chain_datum_tx_item_sign_get_sig(dap_chain_tx_sig_t *a_tx_sig);
/**
* Get item from transaction
@@ -189,4 +161,3 @@ uint8_t* dap_chain_datum_tx_item_get( dap_chain_datum_tx_t *a_tx, int *a_item_id
dap_list_t* dap_chain_datum_tx_items_get(dap_chain_datum_tx_t *a_tx, dap_chain_tx_item_type_t a_type, int *a_item_count);
// Get conditional out item with it's idx
dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num);
-dap_chain_256_tx_out_cond_t *dap_chain_datum_256_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num);
diff --git a/modules/common/include/dap_chain_datum_tx_out.h b/modules/common/include/dap_chain_datum_tx_out.h
index 0394a74ef6ef244c51aec5852a61f34735d3790e..04d6719941520a3ae76365e8aa16854ba9671a08 100644
--- a/modules/common/include/dap_chain_datum_tx_out.h
+++ b/modules/common/include/dap_chain_datum_tx_out.h
@@ -34,7 +34,7 @@
*/
typedef struct dap_chain_tx_out{
struct {
- dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
+ dap_chain_tx_item_type_t type; /// @param type @brief Transaction item type
uint64_t value; /// @param value @brief Number of Datoshis ( DAP/10^9 ) to be transfered
} header; /// Only header's hash is used for verification
dap_chain_addr_t addr; ////
@@ -43,9 +43,8 @@ typedef struct dap_chain_tx_out{
//256
typedef struct dap_chain_256_tx_out{
struct {
- dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
+ dap_chain_tx_item_type_t type; /// @param type @brief Transaction item type
uint256_t value; /// @param value @brief Number of Datoshis ( DAP/10^9 ) to be transfered
} header; /// Only header's hash is used for verification
dap_chain_addr_t addr; ////
} DAP_ALIGN_PACKED dap_chain_256_tx_out_t;
-
diff --git a/modules/common/include/dap_chain_datum_tx_out_cond.h b/modules/common/include/dap_chain_datum_tx_out_cond.h
index 1bbd166f0a7f75bd9318382833e3d34733b56ba7..f98afa1ac91b82438cacbac2af771d036bd95e71 100644
--- a/modules/common/include/dap_chain_datum_tx_out_cond.h
+++ b/modules/common/include/dap_chain_datum_tx_out_cond.h
@@ -29,12 +29,13 @@
#include "dap_chain_common.h"
#include "dap_chain_datum_tx.h"
-typedef enum dap_chain_tx_out_cond_subtype {
+enum dap_chain_tx_out_cond_subtype {
DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY = 0x01,
DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE = 0x02,
DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE = 0x13,
- DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_UPDATE = 0xFA // Virtual type for stake update verificator
-} dap_chain_tx_out_cond_subtype_t;
+ DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_UPDATE = 0xFA // Virtual type for stake update verificator //TODO change it to new type of callback for ledger tx add
+};
+typedef byte_t dap_chain_tx_out_cond_subtype_t;
DAP_STATIC_INLINE const char *dap_chain_tx_out_cond_subtype_to_str(dap_chain_tx_out_cond_subtype_t a_subtype){
switch (a_subtype) {
@@ -53,11 +54,11 @@ DAP_STATIC_INLINE const char *dap_chain_tx_out_cond_subtype_to_str(dap_chain_tx_
typedef struct dap_chain_tx_out_cond {
struct {
/// Transaction item type
- dap_chain_tx_item_type_t item_type :8;
+ dap_chain_tx_item_type_t item_type;
/// Condition subtype
- dap_chain_tx_out_cond_subtype_t subtype : 8;
+ dap_chain_tx_out_cond_subtype_t subtype;
/// Number of Datoshis ( DAP/10^9 ) to be reserver for service
- uint64_t value;
+ uint256_t value;
/// When time expires this output could be used only by transaction owner
dap_chain_time_t ts_expires;
} header;
@@ -71,7 +72,7 @@ typedef struct dap_chain_tx_out_cond {
/// Price unit thats used to check price max
dap_chain_net_srv_price_unit_uid_t unit;
/// Maximum price per unit
- uint64_t unit_price_max_datoshi;
+ uint256_t unit_price_max_datoshi;
} srv_pay;
struct {
// Service uid that only could be used for this outout
@@ -81,7 +82,7 @@ typedef struct dap_chain_tx_out_cond {
// Chain network to change to
dap_chain_net_id_t net_id;
// Total amount of datoshi to change to
- uint64_t value;
+ uint256_t value;
} srv_xchange;
struct {
// Service uid that only could be used for this outout
@@ -103,14 +104,14 @@ typedef struct dap_chain_tx_out_cond {
* @struct dap_chain_tx_out
* @brief Transaction item out_cond
*/
-typedef struct dap_chain_256_tx_out_cond {
+typedef struct dap_chain_tx_out_cond_old { // Obsolete
struct {
/// Transaction item type
- dap_chain_tx_item_type_t item_type :8;
+ dap_chain_tx_item_type_t item_type;
/// Condition subtype
- dap_chain_tx_out_cond_subtype_t subtype : 8;
+ dap_chain_tx_out_cond_subtype_t subtype;
/// Number of Datoshis ( DAP/10^9 ) to be reserver for service
- uint256_t value;
+ uint64_t value;
/// When time expires this output could be used only by transaction owner
dap_chain_time_t ts_expires;
} header;
@@ -124,7 +125,7 @@ typedef struct dap_chain_256_tx_out_cond {
/// Price unit thats used to check price max
dap_chain_net_srv_price_unit_uid_t unit;
/// Maximum price per unit
- uint256_t unit_price_max_datoshi;
+ uint64_t unit_price_max_datoshi;
} srv_pay;
struct {
// Service uid that only could be used for this outout
@@ -134,7 +135,7 @@ typedef struct dap_chain_256_tx_out_cond {
// Chain network to change to
dap_chain_net_id_t net_id;
// Total amount of datoshi to change to
- uint256_t value;
+ uint64_t value;
} srv_xchange;
struct {
// Service uid that only could be used for this outout
@@ -149,8 +150,4 @@ typedef struct dap_chain_256_tx_out_cond {
} subtype;
uint32_t params_size; // Condition parameters size
uint8_t params[]; // condition parameters, pkey, hash or smth like this
-} DAP_ALIGN_PACKED dap_chain_256_tx_out_cond_t;
-
-
-
-
+} DAP_ALIGN_PACKED dap_chain_tx_out_cond_old_t;
diff --git a/modules/common/include/dap_chain_datum_tx_out_ext.h b/modules/common/include/dap_chain_datum_tx_out_ext.h
index 1a310068cb2a0b20160e76798b1ccc214dd49662..6dc527b209a59d675eb5e358c91e581f33d19fa4 100644
--- a/modules/common/include/dap_chain_datum_tx_out_ext.h
+++ b/modules/common/include/dap_chain_datum_tx_out_ext.h
@@ -29,25 +29,11 @@
#include "dap_chain_common.h"
#include "dap_chain_datum_tx.h"
-/**
- * @struct dap_chain_tx_out_ext
- * @brief Multichannel transaction item output
- */
typedef struct dap_chain_tx_out_ext{
struct {
- dap_chain_tx_item_type_t type : 8; // Transaction item type - should be TX_ITEM_TYPE_OUT_EXT
- uint64_t value; // Number of Datoshis ( DAP/10^9 ) to be transfered
+ dap_chain_tx_item_type_t type; // Transaction item type - should be TX_ITEM_TYPE_OUT_EXT
+ uint256_t value; // Number of Datoshis ( DAP/10^9 ) to be transfered
} header; // Only header's hash is used for verification
dap_chain_addr_t addr; // Address to transfer to
char token[DAP_CHAIN_TICKER_SIZE_MAX]; // Which token is transferred
} DAP_ALIGN_PACKED dap_chain_tx_out_ext_t;
-
-// 256
-typedef struct dap_chain_256_tx_out_ext{
- struct {
- dap_chain_tx_item_type_t type : 8; // Transaction item type - should be TX_ITEM_TYPE_OUT_EXT
- uint256_t value; // Number of Datoshis ( DAP/10^9 ) to be transfered
- } header; // Only header's hash is used for verification
- dap_chain_addr_t addr; // Address to transfer to
- char token[DAP_CHAIN_TICKER_SIZE_MAX]; // Which token is transferred
-} DAP_ALIGN_PACKED dap_chain_256_tx_out_ext_t;
diff --git a/modules/common/include/dap_chain_datum_tx_pkey.h b/modules/common/include/dap_chain_datum_tx_pkey.h
index 58a92b631a850e40e1ff1127cf51bab2678bd53f..cfea7b332887388ea590c365cfafff4136e939e1 100644
--- a/modules/common/include/dap_chain_datum_tx_pkey.h
+++ b/modules/common/include/dap_chain_datum_tx_pkey.h
@@ -33,7 +33,7 @@
*/
typedef struct dap_chain_tx_pkey{
struct {
- dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
+ dap_chain_tx_item_type_t type; /// @param type @brief Transaction item type
dap_sign_type_t sig_type; /// Signature type
uint32_t sig_size; /// Signature size
} header; /// Only header's hash is used for verification
diff --git a/modules/common/include/dap_chain_datum_tx_receipt.h b/modules/common/include/dap_chain_datum_tx_receipt.h
index b27f0ce374e6b560d0a8255a245fcc2f389c782f..be45c6405239fb1435ed2e4a376ec52735b40346 100644
--- a/modules/common/include/dap_chain_datum_tx_receipt.h
+++ b/modules/common/include/dap_chain_datum_tx_receipt.h
@@ -32,34 +32,26 @@
* @brief Transaction item out_cond
*/
typedef struct dap_chain_datum_tx_receipt {
- uint8_t type; //dap_chain_tx_item_type_t type :8; // Transaction item type
+ dap_chain_tx_item_type_t type; // Transaction item type
dap_chain_receipt_info_t receipt_info; // Receipt itself
uint16_t size;
uint16_t exts_size;
byte_t exts_n_signs[]; // Signatures, first from provider, second from client
}DAP_ALIGN_PACKED dap_chain_datum_tx_receipt_t;
+
#ifdef __cplusplus
extern "C" {
#endif
static inline size_t dap_chain_datum_tx_receipt_get_size_hdr(){ return 1+sizeof (dap_chain_receipt_info_t)+sizeof (uint16_t) +sizeof (uint16_t); }
-dap_chain_datum_tx_receipt_t * dap_chain_datum_tx_receipt_create( dap_chain_net_srv_uid_t srv_uid,
- dap_chain_net_srv_price_unit_uid_t units_type,
- uint64_t units, uint64_t value_datoshi, const void * a_ext, size_t a_ext_size);
-
-// 256
-dap_chain_datum_tx_receipt_t * dap_chain_datum_256_tx_receipt_create( dap_chain_net_srv_uid_t srv_uid,
+dap_chain_datum_tx_receipt_t * dap_chain_datum_tx_receipt_create(dap_chain_net_srv_uid_t srv_uid,
dap_chain_net_srv_price_unit_uid_t units_type,
uint64_t units, uint256_t value_datoshi, const void * a_ext, size_t a_ext_size);
-
size_t dap_chain_datum_tx_receipt_sign_add(dap_chain_datum_tx_receipt_t ** a_receipt, size_t a_receipt_size, dap_enc_key_t *a_key );
-
dap_sign_t* dap_chain_datum_tx_receipt_sign_get(dap_chain_datum_tx_receipt_t * l_receipt, size_t l_receipt_size , uint16_t sign_position);
-
uint16_t dap_chain_datum_tx_receipt_signs_count(dap_chain_datum_tx_receipt_t * l_receipt, size_t l_receipt_size);
-
static inline uint16_t dap_chain_datum_tx_receipt_get_size(const dap_chain_datum_tx_receipt_t * l_receipt)
{
return l_receipt->size;
diff --git a/modules/common/include/dap_chain_datum_tx_sig.h b/modules/common/include/dap_chain_datum_tx_sig.h
index 8265348babd74220775f53d5f38317ec6ca24b4a..8d6c4f27aa1f57d1f93a306c12c6c421bd325a09 100644
--- a/modules/common/include/dap_chain_datum_tx_sig.h
+++ b/modules/common/include/dap_chain_datum_tx_sig.h
@@ -35,8 +35,7 @@
*/
typedef struct dap_chain_tx_sig{
struct {
- dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
-// dap_sign_type_t sig_type; /// Signature type
+ dap_chain_tx_item_type_t type; /// @param type @brief Transaction item type
uint32_t sig_size; /// Signature size
} header; /// Only header's hash is used for verification
uint8_t sig[]; /// @param sig @brief raw signature data
diff --git a/modules/common/include/dap_chain_datum_tx_token.h b/modules/common/include/dap_chain_datum_tx_token.h
index 65a99a10b3b80d7ea3eda10025e3e4e44f268ccc..f385363a12654da1b948bc462e7afd132bc47f4a 100644
--- a/modules/common/include/dap_chain_datum_tx_token.h
+++ b/modules/common/include/dap_chain_datum_tx_token.h
@@ -34,7 +34,7 @@
*/
typedef struct dap_chain_tx_token{
struct {
- dap_chain_tx_item_type_t type:8;
+ dap_chain_tx_item_type_t type;
char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
uint8_t padding; // Padding
dap_chain_id_t token_emission_chain_id;
@@ -49,7 +49,7 @@ typedef struct dap_chain_tx_token{
*/
typedef struct dap_chain_tx_token_ext{
struct {
- dap_chain_tx_item_type_t type:8;
+ dap_chain_tx_item_type_t type;
uint8_t version;
char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
uint8_t padding1; // Padding
diff --git a/modules/consensus/block-poa/CMakeLists.txt b/modules/consensus/block-poa/CMakeLists.txt
index 086591aba66c41d3e17a19d4b725cb1fea19e9a5..76095fb37dd1d811d5d14f6a6e9e78ba30aeea8d 100644
--- a/modules/consensus/block-poa/CMakeLists.txt
+++ b/modules/consensus/block-poa/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_block_poa)
file(GLOB DAP_CHAIN_BLOCK_CS_POA_SRCS *.c)
diff --git a/modules/consensus/block-poa/dap_chain_cs_block_poa.c b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
index aa93918c49be22d8232d0e8460ff6990e7c3ce4e..3ee2f2763ac720aee661543967cfde8dd18cc4cb 100644
--- a/modules/consensus/block-poa/dap_chain_cs_block_poa.c
+++ b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
@@ -22,6 +22,7 @@
along with any DAP SDK based project. If not, see <http://www.gnu.org/licenses/>.
*/
+#include "dap_chain_net.h"
#include "dap_common.h"
#include "dap_strfuncs.h"
#include "dap_enc_base58.h"
@@ -32,7 +33,6 @@
#include "dap_chain_block_cache.h"
#include "dap_chain_cs_blocks.h"
#include "dap_chain_cs_block_poa.h"
-#include "dap_chain_net.h"
#include "dap_chain_node_cli.h"
#include "dap_chain_node_cli_cmd.h"
#include "dap_chain_global_db.h"
@@ -190,13 +190,15 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
l_poa_pvt->auth_certs = DAP_NEW_Z_SIZE ( dap_cert_t *, l_poa_pvt->auth_certs_count * sizeof(dap_cert_t));
char l_cert_name[512];
for (size_t i = 0; i < l_poa_pvt->auth_certs_count ; i++ ){
- dap_snprintf(l_cert_name,sizeof(l_cert_name),"%s.%lu",l_poa_pvt->auth_certs_prefix, i);
- if ( (l_poa_pvt->auth_certs[i] = dap_cert_find_by_name( l_cert_name)) != NULL ) {
- log_it(L_NOTICE, "Initialized auth cert \"%s\"", l_cert_name);
- } else{
- log_it(L_ERROR, "Can't find cert \"%s\"", l_cert_name);
- return -1;
+ dap_snprintf(l_cert_name,sizeof(l_cert_name),"%s.%zu",l_poa_pvt->auth_certs_prefix, i);
+ if ((l_poa_pvt->auth_certs[i] = dap_cert_find_by_name( l_cert_name)) == NULL) {
+ dap_snprintf(l_cert_name,sizeof(l_cert_name),"%s.%zu.pub",l_poa_pvt->auth_certs_prefix, i);
+ if ((l_poa_pvt->auth_certs[i] = dap_cert_find_by_name( l_cert_name)) == NULL) {
+ log_it(L_ERROR, "Can't find cert \"%s\"", l_cert_name);
+ return -1;
+ }
}
+ log_it(L_NOTICE, "Initialized auth cert \"%s\"", l_cert_name);
}
}
}
@@ -223,7 +225,7 @@ static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_net_c
PVT(l_poa)->prev_callback_created(a_chain,a_chain_net_cfg);
const char * l_sign_cert_str = NULL;
- if ( ( l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg,"block-poa","sign-cert") ) != NULL ) {
+ if ( ( l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg,"block-poa","blocks-sign-cert") ) != NULL ) {
dap_cert_t *l_sign_cert = dap_cert_find_by_name(l_sign_cert_str);
if (l_sign_cert == NULL) {
log_it(L_ERROR, "Can't load sign certificate, name \"%s\" is wrong", l_sign_cert_str);
@@ -278,7 +280,7 @@ static size_t s_callback_block_sign(dap_chain_cs_blocks_t *a_blocks, dap_chain_b
dap_chain_cs_block_poa_t *l_poa = DAP_CHAIN_CS_BLOCK_POA(a_blocks);
dap_chain_cs_block_poa_pvt_t *l_poa_pvt = PVT(l_poa);
if (!l_poa_pvt->sign_key) {
- log_it(L_WARNING, "Can't sign block with sign-cert in [block-poa] section");
+ log_it(L_WARNING, "Can't sign block with blocks-sign-cert in [block-poa] section");
return 0;
}
if (!a_block_ptr || !(*a_block_ptr) || !a_block_size) {
@@ -331,6 +333,7 @@ static int s_callback_block_verify(dap_chain_cs_blocks_t * a_blocks, dap_chain_b
break;
}
}
+ //TODO verify sign itself
l_offset += l_sign_size;
l_sign = (dap_sign_t *)(a_block->meta_n_datum_n_sign + l_offset);
}
diff --git a/modules/consensus/block-pos/CMakeLists.txt b/modules/consensus/block-pos/CMakeLists.txt
index 587d3b2d0219d463bef78a67f7d2ed8dfc62016f..82db9813d05fe2dd9cff3c19cd96c8164462ed8e 100644
--- a/modules/consensus/block-pos/CMakeLists.txt
+++ b/modules/consensus/block-pos/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_block_pos)
file(GLOB DAP_CHAIN_CS_BLOCK_POS_SRCS *.c)
diff --git a/modules/consensus/block-pos/dap_chain_cs_block_pos.c b/modules/consensus/block-pos/dap_chain_cs_block_pos.c
index 90ffe94de3f5e68243181e331605e6c71697be4d..e3976afc8e6d4cd1a8bf67862a5a0e20a50f3ef9 100644
--- a/modules/consensus/block-pos/dap_chain_cs_block_pos.c
+++ b/modules/consensus/block-pos/dap_chain_cs_block_pos.c
@@ -146,7 +146,7 @@ static int s_callback_created(dap_chain_t *a_chain, dap_config_t *a_chain_net_cf
dap_chain_cs_block_pos_t *l_pos = DAP_CHAIN_CS_BLOCK_POS(l_blocks);
const char * l_sign_cert_str = NULL;
- if ( ( l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg,"block-pos","sign-cert") ) != NULL ) {
+ if ((l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg,"block-pos","blocks-sign-cert")) != NULL) {
dap_cert_t *l_sign_cert = dap_cert_find_by_name(l_sign_cert_str);
if (l_sign_cert == NULL) {
log_it(L_ERROR, "Can't load sign certificate, name \"%s\" is wrong", l_sign_cert_str);
@@ -188,7 +188,7 @@ static size_t s_callback_block_sign(dap_chain_cs_blocks_t *a_blocks, dap_chain_b
dap_chain_cs_block_pos_t *l_pos = DAP_CHAIN_CS_BLOCK_POS(a_blocks);
dap_chain_cs_block_pos_pvt_t *l_pos_pvt = PVT(l_pos);
if (!l_pos_pvt->blocks_sign_key) {
- log_it(L_WARNING, "Can't sign block with sign-cert in [block-pos] section");
+ log_it(L_WARNING, "Can't sign block with blocks-sign-cert in [block-pos] section");
return 0;
}
if (!a_block_ptr || !(*a_block_ptr) || !a_block_size) {
diff --git a/modules/consensus/block-pow/CMakeLists.txt b/modules/consensus/block-pow/CMakeLists.txt
index 9f3cc01638bae46853fde94ac5cf5fe0a237561e..ec2ccd4bf15942e0fb9ee3de3cd8228a19980689 100644
--- a/modules/consensus/block-pow/CMakeLists.txt
+++ b/modules/consensus/block-pow/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_block_pow)
file(GLOB DAP_CHAIN_BLOCK_CS_POW_SRCS *.c)
diff --git a/modules/consensus/dag-poa/CMakeLists.txt b/modules/consensus/dag-poa/CMakeLists.txt
index 457d52f9abf7243c6903838c650ec0b595d85a51..69c7fc625840122ee157fa46ffe5f2e0407261df 100644
--- a/modules/consensus/dag-poa/CMakeLists.txt
+++ b/modules/consensus/dag-poa/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_dag_poa)
file(GLOB DAP_CHAIN_DAG_CS_POA_SRCS *.c)
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index a71a7f79b6142b5e1a60dcb85bd6ebf35d933c61..8e7103c53135ceb84251060465abeed499073431 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -268,12 +268,14 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
char l_cert_name[512];
for (size_t i = 0; i < l_poa_pvt->auth_certs_count ; i++ ){
dap_snprintf(l_cert_name,sizeof(l_cert_name),"%s.%zu",l_poa_pvt->auth_certs_prefix, i);
- if ( (l_poa_pvt->auth_certs[i] = dap_cert_find_by_name( l_cert_name)) != NULL ) {
- log_it(L_NOTICE, "Initialized auth cert \"%s\"", l_cert_name);
- } else{
- log_it(L_ERROR, "Can't find cert \"%s\"", l_cert_name);
- return -1;
+ if ((l_poa_pvt->auth_certs[i] = dap_cert_find_by_name( l_cert_name)) == NULL) {
+ dap_snprintf(l_cert_name,sizeof(l_cert_name),"%s.%zu.pub",l_poa_pvt->auth_certs_prefix, i);
+ if ((l_poa_pvt->auth_certs[i] = dap_cert_find_by_name( l_cert_name)) == NULL) {
+ log_it(L_ERROR, "Can't find cert \"%s\"", l_cert_name);
+ return -1;
+ }
}
+ log_it(L_NOTICE, "Initialized auth cert \"%s\"", l_cert_name);
}
}
}
@@ -351,6 +353,7 @@ static dap_chain_cs_dag_event_t * s_callback_event_create(dap_chain_cs_dag_t * a
dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count, size_t* a_event_size)
{
dap_return_val_if_fail(a_dag && a_dag->chain && DAP_CHAIN_CS_DAG_POA(a_dag), NULL);
+ dap_chain_net_t * l_net = dap_chain_net_by_name( a_dag->chain->net_name );
dap_chain_cs_dag_poa_t * l_poa = DAP_CHAIN_CS_DAG_POA(a_dag);
if ( PVT(l_poa)->events_sign_cert == NULL){
log_it(L_ERROR, "Can't sign event with events_sign_cert in [dag-poa] section");
diff --git a/modules/consensus/dag-pos/CMakeLists.txt b/modules/consensus/dag-pos/CMakeLists.txt
index 33b2032af8fdda1b7e8f751d0c06ebb0899b0e00..1e5cecca4333ca95873fbe794694732148f98ee3 100644
--- a/modules/consensus/dag-pos/CMakeLists.txt
+++ b/modules/consensus/dag-pos/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_dag_pos)
file(GLOB DAP_CHAIN_CS_DAG_POS_SRCS *.c)
diff --git a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c b/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
index 72e5876bf81ac50f72f8c5bc5ee13cf57c9a6b4a..768d985e759ffe368f0c1b08d3cd2b65d8c391b2 100644
--- a/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
+++ b/modules/consensus/dag-pos/dap_chain_cs_dag_pos.c
@@ -147,18 +147,19 @@ static int s_callback_created(dap_chain_t * a_chain, dap_config_t *a_chain_net_c
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG ( a_chain );
dap_chain_cs_dag_pos_t * l_pos = DAP_CHAIN_CS_DAG_POS( l_dag );
- const char * l_events_sign_wallet = NULL;
- if ( ( l_events_sign_wallet = dap_config_get_item_str(a_chain_net_cfg,"dag-pos","events-sign-wallet") ) != NULL ) {
-
- dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_events_sign_wallet, dap_chain_wallet_get_path(g_config));
- if (!l_wallet) {
- log_it(L_ERROR,"Can't load events sign wallet, name \"%s\" is wrong", l_events_sign_wallet);
+ const char * l_sign_cert_str = NULL;
+ if ((l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg, "dag-pos", "events-sign-cert")) != NULL) {
+ dap_cert_t *l_sign_cert = dap_cert_find_by_name(l_sign_cert_str);
+ if (l_sign_cert == NULL) {
+ log_it(L_ERROR, "Can't load sign certificate, name \"%s\" is wrong", l_sign_cert_str);
+ } else if (l_sign_cert->enc_key->priv_key_data) {
+ PVT(l_pos)->events_sign_key = l_sign_cert->enc_key;
+ log_it(L_NOTICE, "Loaded \"%s\" certificate to sign PoS events", l_sign_cert_str);
} else {
- PVT(l_pos)->events_sign_key = dap_chain_wallet_get_key(l_wallet, 0);
- log_it(L_NOTICE,"Loaded \"%s\" wallet to sign pos event", l_events_sign_wallet);
+ log_it(L_ERROR, "Certificate \"%s\" has no private key", l_sign_cert_str);
}
} else {
- log_it(L_WARNING, "Events sign wallet is empty for %s chain, can't sing any events for it", a_chain->name);
+ log_it(L_ERROR, "No sign certificate provided, can't sign any events");
}
return 0;
}
@@ -269,40 +270,6 @@ static int s_callback_event_verify(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_
return -6;
}
}
- /*
- dap_chain_datum_t *l_datum = dap_chain_cs_dag_event_get_datum(a_dag_event);
- // transaction include emission?
- bool l_is_emit = false;
- if(l_datum && l_datum->header.type_id == DAP_CHAIN_DATUM_TX) {
- // transaction
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
- // find Token items
- dap_list_t *l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
- if(l_list_tx_token)
- l_is_emit = true;
- dap_list_free(l_list_tx_token);
- }
- // if emission then the wallet can be with zero balance
- if(l_is_emit)
- return 0;*/
-
- // bool l_is_enough_balance = false;
- // for (size_t i =0; i <l_pos_pvt->tokens_hold_size; i++){
- // uint256_t l_balance = dap_chain_ledger_calc_balance ( a_dag->chain->ledger , &l_addr, l_pos_pvt->tokens_hold[i] );
- // uint64_t l_value = dap_chain_uint256_to(l_balance);
- // if (l_value >= l_pos_pvt->tokens_hold_value[i]) {
- // l_verified_num++;
- // l_is_enough_balance = true;
- // break;
- // }
- // }
- // if (! l_is_enough_balance ){
- // char *l_addr_str = dap_chain_addr_to_str(&l_addr);
- // log_it(L_WARNING, "Verify of event is false, because bal is not enough for addr=%s", l_addr_str);
- // DAP_DELETE(l_addr_str);
- // return -1;
- //}
-
}
// Check number
if ( l_verified_num >= l_pos_pvt->confirmations_minimum ){
diff --git a/modules/consensus/none/CMakeLists.txt b/modules/consensus/none/CMakeLists.txt
index 8072379783889069d785c766ac0b10d786fbe24c..ddf73b014ea1143a5a1c663582a517c424137c7c 100644
--- a/modules/consensus/none/CMakeLists.txt
+++ b/modules/consensus/none/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_none)
file(GLOB DAP_CHAIN_CS_NO_CONSENSUS_SRC *.c)
diff --git a/modules/consensus/none/dap_chain_cs_none.c b/modules/consensus/none/dap_chain_cs_none.c
index 2cc6f6d04ed91ce54ee5913da1571cc65598c343..d6509844a748ba6bc58c3f4b61d08d81017756f2 100644
--- a/modules/consensus/none/dap_chain_cs_none.c
+++ b/modules/consensus/none/dap_chain_cs_none.c
@@ -177,10 +177,11 @@ int dap_chain_gdb_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
l_gdb_priv->chain = a_chain;
if(!l_gdb_priv->celled){
- l_gdb_priv->group_datums = dap_strdup_printf( "chain-gdb.%s.chain-%016"DAP_UINT64_FORMAT_X,l_net->pub.name,
+ l_gdb_priv->group_datums = dap_strdup_printf( "chain-gdb.%s.chain-%016llX",l_net->pub.name,
a_chain->id.uint64);
}else {
- l_gdb_priv->group_datums = dap_strdup_printf( "chain-gdb.%s.chain-%016"DAP_UINT64_FORMAT_X".cell-%016"DAP_UINT64_FORMAT_X,l_net->pub.name,
+ // here is not work because dap_chain_net_load() not yet fully performed
+ l_gdb_priv->group_datums = dap_strdup_printf( "chain-gdb.%s.chain-%016llX.cell-%016llX",l_net->pub.name,
a_chain->id.uint64, a_chain->cells->id.uint64);
}
@@ -268,6 +269,7 @@ const char* dap_chain_gdb_get_group(dap_chain_t * a_chain)
return 1;
}*/
+
/**
* @brief Load ledger from mempool
*
@@ -343,21 +345,14 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
return ATOM_REJECT;
}
switch (l_datum->header.type_id) {
- case DAP_CHAIN_DATUM_256_TOKEN_DECL: // 256
case DAP_CHAIN_DATUM_TOKEN_DECL:{
- dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
- if (dap_chain_ledger_token_load(a_chain->ledger,l_token, l_datum->header.data_size))
+ if (dap_chain_ledger_token_load(a_chain->ledger, (dap_chain_datum_token_t *)l_datum->data, l_datum->header.data_size))
return ATOM_REJECT;
}break;
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
- // l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- // true : false;
- if (dap_chain_ledger_token_emission_load(a_chain->ledger, (dap_chain_datum_token_emission_t*) l_datum->data, l_datum->header.data_size))
+ if (dap_chain_ledger_token_emission_load(a_chain->ledger, l_datum->data, l_datum->header.data_size))
return ATOM_REJECT;
}break;
- case DAP_CHAIN_DATUM_256_TX: // 256
case DAP_CHAIN_DATUM_TX:{
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
// No trashhold herr, don't save bad transactions to base
@@ -387,6 +382,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
return ATOM_ACCEPT;
}
+
/**
* @brief Verify atomic element (currently simply return ATOM_ACCEPT)
*
@@ -415,6 +411,7 @@ static size_t s_chain_callback_atom_get_static_hdr_size()
return sizeof(l_datum_null->header);
}
+
/**
* @brief Create atomic element iterator
*
@@ -431,11 +428,11 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_
/**
* @brief create atom object (dap_chain_atom_iter_t)
- *
+ *
* @param a_chain chain object
* @param a_atom pointer to atom
* @param a_atom_size size of atom
- * @return dap_chain_atom_iter_t*
+ * @return dap_chain_atom_iter_t*
*/
static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t * a_chain,
dap_chain_atom_ptr_t a_atom, size_t a_atom_size)
@@ -444,9 +441,11 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
l_iter->chain = a_chain;
l_iter->cur = a_atom;
l_iter->cur_size = a_atom_size;
+ dap_hash_fast(a_atom, a_atom_size, l_iter->cur_hash);
return l_iter;
}
+
/**
* @brief Delete dag event iterator
* execute DAP_DELETE(a_atom_iter)
@@ -454,16 +453,20 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
*/
static void s_chain_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter)
{
+ if (a_atom_iter->cur_item)
+ DAP_DELETE(a_atom_iter->cur_item);
+ DAP_DELETE(a_atom_iter->cur_hash);
DAP_DELETE(a_atom_iter);
}
+
/**
* @brief get dap_chain_atom_ptr_t object form database by hash
- * @details Searchs by datum data hash, not for datum's hash itself
- * @param a_atom_iter dap_chain_atom_iter_t atom object
+ * @details Searchs by datum data hash, not for datum's hash itself
+ * @param a_atom_iter dap_chain_atom_iter_t atom object
* @param a_atom_hash dap_chain_hash_fast_t atom hash
* @param a_atom_size size of atom object
- * @return dap_chain_atom_ptr_t
+ * @return dap_chain_atom_ptr_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)
@@ -480,54 +483,70 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_find_by_hash(dap_chain_at
/**
* @brief Get the first dag event from database
- *
- * @param a_atom_iter ap_chain_atom_iter_t object
+ *
+ * @param a_atom_iter ap_chain_atom_iter_t object
* @param a_atom_size a_atom_size atom size
- * @return dap_chain_atom_ptr_t
+ * @return dap_chain_atom_ptr_t
*/
static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_first(dap_chain_atom_iter_t * a_atom_iter, size_t *a_atom_size)
{
if (!a_atom_iter)
return NULL;
dap_chain_datum_t * l_datum = NULL;
- a_atom_iter->cur_item = PVT ( DAP_CHAIN_GDB(a_atom_iter->chain) )->hash_items;
+ dap_chain_gdb_datum_hash_item_t *l_item = PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->hash_items;
+ a_atom_iter->cur_item = l_item;
if (a_atom_iter->cur_item ){
- dap_chain_gdb_datum_hash_item_t * l_item = PVT ( DAP_CHAIN_GDB(a_atom_iter->chain) )->hash_items;
size_t l_datum_size =0;
- l_datum= (dap_chain_datum_t*) dap_chain_global_db_gr_get(l_item->key,&l_datum_size,PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->group_datums );
+ l_datum= (dap_chain_datum_t*) dap_chain_global_db_gr_get(l_item->key, &l_datum_size,
+ PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->group_datums );
if (a_atom_iter->cur) // This iterator should clean up data for it because its allocate it
DAP_DELETE( a_atom_iter->cur);
a_atom_iter->cur = l_datum;
+ a_atom_iter->cur_size = l_datum_size;
+ dap_chain_hash_fast_from_str(l_item->key, a_atom_iter->cur_hash);
if (a_atom_size)
*a_atom_size = l_datum_size;
- } else if (a_atom_size)
- *a_atom_size = 0;
+ } else {
+ DAP_DEL_Z(a_atom_iter->cur);
+ a_atom_iter->cur_size = 0;
+ if (a_atom_size)
+ *a_atom_size = 0;
+ }
return l_datum;
}
+
/**
* @brief Get the next dag event from database
- *
+ *
* @param a_atom_iter dap_chain_atom_iter_t
* @param a_atom_size size_t a_atom_size
- * @return dap_chain_atom_ptr_t
+ * @return dap_chain_atom_ptr_t
*/
-static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_next(dap_chain_atom_iter_t * a_atom_iter,size_t *a_atom_size)
+static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_next(dap_chain_atom_iter_t *a_atom_iter, size_t *a_atom_size)
{
dap_chain_datum_t * l_datum = NULL;
- a_atom_iter->cur_item = a_atom_iter->cur_item?
- ((dap_chain_gdb_datum_hash_item_t*) a_atom_iter->cur_item)->next : NULL;
+ dap_chain_gdb_datum_hash_item_t *l_item = (dap_chain_gdb_datum_hash_item_t*)a_atom_iter->cur_item;
+ if (l_item)
+ l_item = l_item->next;
+ a_atom_iter->cur_item = l_item;
if (a_atom_iter->cur_item ){
size_t l_datum_size =0;
- l_datum= (dap_chain_datum_t*) dap_chain_global_db_gr_get(
- ((dap_chain_gdb_datum_hash_item_t*) a_atom_iter->cur_item)->key,
- &l_datum_size, PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->group_datums );
+ l_datum = (dap_chain_datum_t *)dap_chain_global_db_gr_get(l_item->key, &l_datum_size,
+ PVT(DAP_CHAIN_GDB(a_atom_iter->chain))->group_datums);
if (a_atom_iter->cur) // This iterator should clean up data for it because its allocate it
- DAP_DELETE( a_atom_iter->cur);
+ DAP_DELETE(a_atom_iter->cur);
a_atom_iter->cur = l_datum;
- *a_atom_size = l_datum_size;
- }else
- *a_atom_size = 0;
+ a_atom_iter->cur_size = l_datum_size;
+ dap_chain_hash_fast_from_str(l_item->key, a_atom_iter->cur_hash);
+ if (a_atom_size)
+ *a_atom_size = l_datum_size;
+ } else {
+ DAP_DEL_Z(a_atom_iter->cur);
+ a_atom_iter->cur_size = 0;
+ if (a_atom_size)
+ *a_atom_size = 0;
+ }
return l_datum;
}
diff --git a/modules/global-db/dap_chain_global_db.c b/modules/global-db/dap_chain_global_db.c
index 89d1fbd18ad9ab89166f48dffea62acc494ab387..7d714677cbc2ced25c5fce0325cb60d9b0d3e241 100644
--- a/modules/global-db/dap_chain_global_db.c
+++ b/modules/global-db/dap_chain_global_db.c
@@ -330,13 +330,9 @@ uint8_t * dap_chain_global_db_get(const char *a_key, size_t *a_data_len_out)
*/
static bool global_db_gr_del_add(char *a_key,const char *a_group, time_t a_timestamp)
{
- dap_store_obj_t store_data;
- memset(&store_data, 0, sizeof(dap_store_obj_t));
+ dap_store_obj_t store_data = {};
store_data.type = 'a';
store_data.key = a_key;
- // no data
- store_data.value = NULL;
- store_data.value_len = 0;
// group = parent group + '.del'
store_data.group = dap_strdup_printf("%s.del", a_group);
store_data.timestamp = a_timestamp;
@@ -621,7 +617,7 @@ bool dap_chain_global_db_gr_del(char *a_key,const char *a_group)
unlock();
if(l_res >= 0) {
// add to Del group
- global_db_gr_del_add(dap_strdup(a_key), store_data.group, store_data.timestamp);
+ global_db_gr_del_add(dap_strdup(a_key), store_data.group, time(NULL));
}
// do not add to history if l_res=1 (already deleted)
if (!l_res) {
diff --git a/modules/global-db/dap_chain_global_db_driver.c b/modules/global-db/dap_chain_global_db_driver.c
index 4e41cd5dd65b65a6dc8e5a36b3b9f93148a09a40..fe0a48daa53f88a66b4894d8a166d536c084504d 100644
--- a/modules/global-db/dap_chain_global_db_driver.c
+++ b/modules/global-db/dap_chain_global_db_driver.c
@@ -449,17 +449,19 @@ int dap_chain_global_db_driver_appy(pdap_store_obj_t a_store_obj, size_t a_store
for(size_t i = 0; i < a_store_count; i++) {
dap_store_obj_t *l_store_obj_cur = a_store_obj + i;
assert(l_store_obj_cur);
+ char *l_cur_key = dap_strdup(l_store_obj_cur->key);
int l_ret_tmp = s_drv_callback.apply_store_obj(l_store_obj_cur);
if(l_ret_tmp == 1) {
- log_it(L_INFO, "item is missing (may be already deleted) %s/%s\n", l_store_obj_cur->group, l_store_obj_cur->key);
+ log_it(L_INFO, "Item is missing (may be already deleted) %s/%s\n", l_store_obj_cur->group, l_cur_key);
l_ret = 1;
- break;
}
if(l_ret_tmp < 0) {
- log_it(L_ERROR, "Can't write item %s/%s (code %d)\n", l_store_obj_cur->group, l_store_obj_cur->key, l_ret_tmp);
+ log_it(L_ERROR, "Can't write item %s/%s (code %d)\n", l_store_obj_cur->group, l_cur_key, l_ret_tmp);
l_ret -= 1;
- break;
}
+ DAP_DELETE(l_cur_key);
+ if (l_ret)
+ break;
}
if(a_store_count > 1 && s_drv_callback.transaction_end)
@@ -517,7 +519,7 @@ size_t dap_chain_global_db_driver_count(const char *a_group, uint64_t id)
* @param a_group_mask the group mask string
* @return If successful, returns the list of group names, otherwise NULL.
*/
-dap_list_t* dap_chain_global_db_driver_get_groups_by_mask(const char *a_group_mask)
+dap_list_t *dap_chain_global_db_driver_get_groups_by_mask(const char *a_group_mask)
{
dap_list_t *l_list = NULL;
if(s_drv_callback.get_groups_by_mask)
diff --git a/modules/global-db/dap_chain_global_db_driver_cdb.c b/modules/global-db/dap_chain_global_db_driver_cdb.c
index 0b647cc4ff8cc6a21702886bb45d7e0c471987e9..699f07942d106f464d4b3f4459bf7328c1acf8ec 100644
--- a/modules/global-db/dap_chain_global_db_driver_cdb.c
+++ b/modules/global-db/dap_chain_global_db_driver_cdb.c
@@ -585,6 +585,13 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
if(!a_store_obj->key) {
return -2;
}
+ /*if (dap_fnmatch("*.del", a_store_obj->group, 0)) {
+ char *l_del_group = dap_strdup_printf("%s.del", a_store_obj->group);
+ pcdb_instance l_cdb_d = dap_cdb_get_db_by_group(l_del_group);
+ if (l_cdb_d) {
+ l_cdb_i->id = max(l_cdb_d->id, l_cdb_i->id);
+ }
+ }*/
cdb_record l_rec;
l_rec.key = a_store_obj->key; //dap_strdup(a_store_obj->key);
int offset = 0;
diff --git a/modules/global-db/dap_chain_global_db_driver_pgsql.c b/modules/global-db/dap_chain_global_db_driver_pgsql.c
index 1232f9837bb27b5d8b2b5a7388cf25cfaaa7e98c..2722bed4207fec3501af157dd2c53a488e241a83 100644
--- a/modules/global-db/dap_chain_global_db_driver_pgsql.c
+++ b/modules/global-db/dap_chain_global_db_driver_pgsql.c
@@ -191,7 +191,7 @@ int dap_db_driver_pgsql_init(const char *a_filename_dir, dap_db_driver_callbacks
}
/**
- * @brief Deinitializes a SQLite database.
+ * @brief Deinitializes a PostgreSQL database.
*
* @return Returns 0 if successful.
*/
@@ -206,7 +206,7 @@ int dap_db_driver_pgsql_deinit(void)
}
/**
- * @brief Starts a transaction.
+ * @brief Starts a transaction in a PostgreSQL database.
*
* @return Returns 0 if successful, otherwise -1.
*/
@@ -227,7 +227,7 @@ int dap_db_driver_pgsql_start_transaction(void)
}
/**
- * @brief Starts a transaction in a PostgreSQL database.
+ * @brief Ends a transaction in a PostgreSQL database.
*
* @return Returns 0 if successful, otherwise -1.
*/
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 57ab6c1758cf566a439b746d93a3fb0ea00cd46a..a853e58f93e1ab269ccc2486062191fa747ed1d4 100644
--- a/modules/global-db/dap_chain_global_db_driver_sqlite.c
+++ b/modules/global-db/dap_chain_global_db_driver_sqlite.c
@@ -191,14 +191,14 @@ sqlite3* dap_db_driver_sqlite_open(const char *a_filename_utf8, int a_flags, cha
{
sqlite3 *l_db = NULL;
- int l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_NOMUTEX, NULL);
+ int l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_FULLMUTEX, NULL);
// if unable to open the database file
if(l_rc == SQLITE_CANTOPEN) {
log_it(L_WARNING,"No database on path %s, creating one from scratch", a_filename_utf8);
if(l_db)
sqlite3_close(l_db);
// try to create database
- l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_NOMUTEX| SQLITE_OPEN_CREATE, NULL);
+ l_rc = sqlite3_open_v2(a_filename_utf8, &l_db, a_flags | SQLITE_OPEN_FULLMUTEX| SQLITE_OPEN_CREATE, NULL);
}
if(l_rc != SQLITE_OK) {
@@ -608,16 +608,11 @@ int dap_db_driver_sqlite_apply_store_obj(dap_store_obj_t *a_store_obj)
if(a_store_obj->type == 'a') {
if(!a_store_obj->key)
return -1;
- //dap_chain_hash_fast_t l_hash;
- //dap_hash_fast(a_store_obj->value, a_store_obj->value_len, &l_hash);
-
- char *l_blob_hash = "";//dap_db_driver_get_string_from_blob((uint8_t*) &l_hash, sizeof(dap_chain_hash_fast_t));
char *l_blob_value = dap_db_driver_get_string_from_blob(a_store_obj->value, (int)a_store_obj->value_len);
DAP_DEL_Z(a_store_obj->value);
//add one record
- l_query = sqlite3_mprintf("insert into '%s' values(NULL, '%s', x'%s', '%lld', x'%s')",
- l_table_name, a_store_obj->key, l_blob_hash, a_store_obj->timestamp, l_blob_value);
- //dap_db_driver_sqlite_free(l_blob_hash);
+ l_query = sqlite3_mprintf("insert into '%s' values(NULL, '%s', x'', '%lld', x'%s')",
+ l_table_name, a_store_obj->key, a_store_obj->timestamp, l_blob_value);
dap_db_driver_sqlite_free(l_blob_value);
}
else if (a_store_obj->type == 'd') {
diff --git a/modules/global-db/dap_chain_global_db_hist.c b/modules/global-db/dap_chain_global_db_hist.c
index aafef57f07da99f0fb8317dd8e98fe7c285a5cd0..6ff0e7871008a90a8d6f1ad15fdfb613056dc9e8 100644
--- a/modules/global-db/dap_chain_global_db_hist.c
+++ b/modules/global-db/dap_chain_global_db_hist.c
@@ -12,7 +12,7 @@
#include "dap_chain_global_db_hist.h"
#include "uthash.h"
-//#define GDB_SYNC_ALWAYS_FROM_ZERO
+#define GDB_SYNC_ALWAYS_FROM_ZERO
// for dap_db_history()
typedef struct dap_tx_data{
diff --git a/modules/global-db/dap_chain_global_db_remote.c b/modules/global-db/dap_chain_global_db_remote.c
index 3c51d5bec51b247045e1f4041e8fb7957ed6162f..e1c5d27c1309c8cfacb2a4938f3cb622d5865d42 100644
--- a/modules/global-db/dap_chain_global_db_remote.c
+++ b/modules/global-db/dap_chain_global_db_remote.c
@@ -11,7 +11,7 @@
#define LOG_TAG "dap_chain_global_db_remote"
-// default time of node address expired in hours
+// Default time of a node address expired in hours
#define NODE_TIME_EXPIRED_DEFAULT 720
/**
diff --git a/modules/mempool/CMakeLists.txt b/modules/mempool/CMakeLists.txt
index b337f93df4d86b0d331ad9c9ba7cbaed078a5d21..95fc039743247a984eed5068182cc11958ac4d6c 100644
--- a/modules/mempool/CMakeLists.txt
+++ b/modules/mempool/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_mempool)
file(GLOB DAP_CHAIN_MEMPOOL_SRC *.c)
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 8834d39989aaf83202bff19f6b2f6bd546b9444d..5685e903c6bb026a3d1f3bf19b819f6faaaef9ee 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -108,17 +108,18 @@ dap_hash_fast_t* dap_chain_mempool_tx_create(dap_chain_t * a_chain, dap_enc_key_
const dap_chain_addr_t* a_addr_from, const dap_chain_addr_t* a_addr_to,
const dap_chain_addr_t* a_addr_fee,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value, uint64_t a_value_fee)
+ uint256_t a_value, uint256_t a_value_fee)
{
// check valid param
if(!a_chain | !a_key_from || ! a_addr_from || !a_key_from->priv_key_data || !a_key_from->priv_key_data_size ||
!dap_chain_addr_check_sum(a_addr_from) || !dap_chain_addr_check_sum(a_addr_to) ||
- (a_addr_fee && !dap_chain_addr_check_sum(a_addr_fee)) || !a_value)
+ (a_addr_fee && !dap_chain_addr_check_sum(a_addr_fee)) || IS_ZERO_256(a_value))
return NULL;
// find the transactions from which to take away coins
- uint64_t l_value_transfer = 0; // how many coins to transfer
- uint64_t l_value_need = a_value + a_value_fee;
+ uint256_t l_value_transfer = {}; // how many coins to transfer
+ uint256_t l_value_need;
+ SUM_256_256(a_value, a_value_fee, &l_value_need);
dap_list_t *l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(a_chain->ledger, a_token_ticker,
a_addr_from, l_value_need, &l_value_transfer);
if (!l_list_used_out) {
@@ -129,24 +130,25 @@ dap_hash_fast_t* dap_chain_mempool_tx_create(dap_chain_t * a_chain, dap_enc_key_
dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
// add 'in' items
{
- uint64_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
- assert(l_value_to_items == l_value_transfer);
+ uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
+ assert(EQUAL_256(l_value_to_items, l_value_transfer));
dap_list_free_full(l_list_used_out, free);
}
// add 'out' items
{
- uint64_t l_value_pack = 0; // how much datoshi add to 'out' items
+ uint256_t l_value_pack = {}; // how much datoshi add to 'out' items
if(dap_chain_datum_tx_add_out_item(&l_tx, a_addr_to, a_value) == 1) {
- l_value_pack += a_value;
+ SUM_256_256(l_value_pack, a_value, &l_value_pack);
// transaction fee
if(a_addr_fee) {
if(dap_chain_datum_tx_add_out_item(&l_tx, a_addr_fee, a_value_fee) == 1)
- l_value_pack += a_value_fee;
+ SUM_256_256(l_value_pack, a_value_fee, &l_value_pack);
}
}
// coin back
- uint64_t l_value_back = l_value_transfer - l_value_pack;
- if(l_value_back) {
+ uint256_t l_value_back;
+ SUBTRACT_256_256(l_value_transfer, l_value_pack, &l_value_back);
+ if(!IS_ZERO_256(l_value_back)) {
if(dap_chain_datum_tx_add_out_item(&l_tx, a_addr_from, l_value_back) != 1) {
dap_chain_datum_tx_delete(l_tx);
return NULL;
@@ -185,24 +187,27 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
const dap_chain_addr_t* a_addr_from, const dap_chain_addr_t* a_addr_to,
const dap_chain_addr_t* a_addr_fee,
const char a_token_ticker[10],
- uint64_t a_value, uint64_t a_value_fee,size_t a_tx_num)
+ uint256_t a_value, uint256_t a_value_fee,size_t a_tx_num)
{
// check valid param
if(!a_chain | !a_key_from || !a_addr_from || !a_key_from->priv_key_data || !a_key_from->priv_key_data_size ||
!dap_chain_addr_check_sum(a_addr_from) || !dap_chain_addr_check_sum(a_addr_to) ||
- (a_addr_fee && !dap_chain_addr_check_sum(a_addr_fee)) || !a_value || !a_tx_num){
+ (a_addr_fee && !dap_chain_addr_check_sum(a_addr_fee)) || IS_ZERO_256(a_value) || !a_tx_num){
log_it(L_ERROR, "Wrong parameters in dap_chain_mempool_tx_create_massive() call");
return -1;
}
- dap_global_db_obj_t * l_objs = DAP_NEW_Z_SIZE(dap_global_db_obj_t, (a_tx_num+1)*sizeof (dap_global_db_obj_t) );
+ dap_global_db_obj_t * l_objs = DAP_NEW_Z_SIZE(dap_global_db_obj_t, (a_tx_num + 1) * sizeof (dap_global_db_obj_t));
// Search unused out:
- uint64_t l_value_need =a_tx_num*( a_value + a_value_fee );
- uint64_t l_value_transfer = 0; // how many coins to transfer
- log_it(L_DEBUG,"Create %"DAP_UINT64_FORMAT_U" transactions, summary %Lf.7", a_tx_num,dap_chain_datoshi_to_coins(l_value_need) ) ;
+ uint256_t l_single_val = {};
+ SUM_256_256(a_value, a_value_fee, &l_single_val);
+ uint256_t l_value_need = {};
+ MULT_256_256(dap_chain_uint256_from(a_tx_num), l_single_val, &l_value_need);
+ uint256_t l_value_transfer = {}; // how many coins to transfer
+ log_it(L_DEBUG,"Create %"DAP_UINT64_FORMAT_U" transactions, summary %s", a_tx_num, dap_chain_balance_to_coins(l_value_need)) ;
dap_list_t *l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(a_chain->ledger, a_token_ticker,
a_addr_from, l_value_need, &l_value_transfer);
if (!l_list_used_out) {
@@ -217,52 +222,52 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
// create empty transaction
dap_chain_datum_tx_t *l_tx_new = dap_chain_datum_tx_create();
- uint64_t l_value_back=0;
+ uint256_t l_value_back = {};
// add 'in' items
dap_list_t *l_list_tmp = l_list_used_out;
- uint64_t l_value_to_items = 0; // how many coins to transfer
+ uint256_t l_value_to_items = {}; // how many coins to transfer
// Add in and remove out used items
while(l_list_tmp) {
- list_used_item_t *item = l_list_tmp->data;
+ list_used_item_t *l_item = l_list_tmp->data;
char l_in_hash_str[70];
- dap_chain_hash_fast_to_str(&item->tx_hash_fast,l_in_hash_str,sizeof (l_in_hash_str) );
+ dap_chain_hash_fast_to_str(&l_item->tx_hash_fast,l_in_hash_str,sizeof (l_in_hash_str) );
- if(dap_chain_datum_tx_add_in_item(&l_tx_new, &item->tx_hash_fast, (uint32_t) item->num_idx_out) == 1) {
- l_value_to_items += item->value;
- log_it(L_DEBUG,"Added input %s with %"DAP_UINT64_FORMAT_U" datoshi",l_in_hash_str, item->value);
+ if(dap_chain_datum_tx_add_in_item(&l_tx_new, &l_item->tx_hash_fast, (uint32_t)l_item->num_idx_out) == 1) {
+ SUM_256_256(l_value_to_items, l_item->value, &l_value_to_items);
+ log_it(L_DEBUG, "Added input %s with %s datoshi", l_in_hash_str, dap_chain_balance_print(l_item->value));
}else{
- log_it(L_WARNING,"Can't add input from %s with %"DAP_UINT64_FORMAT_U" datoshi",l_in_hash_str, item->value);
+ log_it(L_WARNING, "Can't add input from %s with %s datoshi", l_in_hash_str, dap_chain_balance_print(l_item->value));
}
l_list_used_out = l_list_tmp->next;
DAP_DELETE(l_list_tmp->data);
dap_list_free1(l_list_tmp);
l_list_tmp = l_list_used_out;
- if ( l_value_to_items >= l_value_transfer )
+ if (compare256(l_value_to_items, l_value_transfer) != -1)
break;
}
- if ( l_value_to_items < (a_value + a_value_fee) ){
- log_it(L_ERROR,"Not enought values on output %"DAP_UINT64_FORMAT_U" to produce enought ins %"DAP_UINT64_FORMAT_U" when need %"DAP_UINT64_FORMAT_U"",
- l_value_to_items, l_value_transfer,
- l_value_need);
+ if (compare256(l_value_to_items, l_single_val) == -1) {
+ log_it(L_ERROR, "Not enought values on output %s to produce enought ins %s when need %s",
+ dap_chain_balance_print(l_value_to_items), dap_chain_balance_print(l_value_transfer),
+ dap_chain_balance_print(l_value_need));
DAP_DELETE(l_objs);
return -5;
}
// add 'out' items
- uint64_t l_value_pack = 0; // how much coin add to 'out' items
+ uint256_t l_value_pack = {}; // how much coin add to 'out' items
if(dap_chain_datum_tx_add_out_item(&l_tx_new, a_addr_to, a_value) == 1) {
- l_value_pack += a_value;
+ SUM_256_256(l_value_pack, a_value, &l_value_pack);
// transaction fee
if(a_addr_fee) {
if(dap_chain_datum_tx_add_out_item(&l_tx_new, a_addr_fee, a_value_fee) == 1)
- l_value_pack += a_value_fee;
+ SUM_256_256(l_value_pack, a_value_fee, &l_value_pack);
}
}
// coin back
- l_value_back = l_value_transfer - l_value_pack;
- if(l_value_back) {
+ SUBTRACT_256_256(l_value_transfer, l_value_pack, &l_value_back);
+ if (!IS_ZERO_256(l_value_back)) {
//log_it(L_DEBUG,"Change back %"DAP_UINT64_FORMAT_U"", l_value_back);
if(dap_chain_datum_tx_add_out_item(&l_tx_new, a_addr_from, l_value_back) != 1) {
dap_chain_datum_tx_delete(l_tx_new);
@@ -281,7 +286,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
dap_chain_hash_fast_t l_tx_new_hash;
dap_hash_fast(l_tx_new, l_tx_size, &l_tx_new_hash);
// If we have value back - update balance cache
- if(l_value_back) {
+ if (!IS_ZERO_256(l_value_back)) {
//log_it(L_DEBUG,"We have value back %"DAP_UINT64_FORMAT_U" now lets see how many outputs we have", l_value_back);
int l_item_count = 0;
dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get( l_tx_new, TX_ITEM_TYPE_OUT,
@@ -311,7 +316,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
//log_it(L_DEBUG,"Checked all outputs");
dap_list_free( l_list_out_items);
}
- l_value_transfer -= l_value_pack;
+ SUBTRACT_256_256(l_value_transfer, l_value_pack, &l_value_transfer);
// Now produce datum
dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx_new, l_tx_size);
@@ -321,7 +326,7 @@ int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a
l_objs[i].key = dap_chain_hash_fast_to_str_new(&l_tx_new_hash);
//continue;
- l_objs[i].value = (uint8_t*) l_datum;
+ l_objs[i].value = (uint8_t *)l_datum;
l_objs[i].value_len = l_tx_size + sizeof(l_datum->header);
log_it(L_DEBUG, "Prepared obj with key %s (value_len = %"DAP_UINT64_FORMAT_U")",
l_objs[i].key? l_objs[i].key :"NULL" , l_objs[i].value_len );
@@ -363,10 +368,10 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *
// create empty transaction
dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
- uint16_t pos=0;
+ uint16_t pos = 0;
dap_chain_datum_tx_add_item(&l_tx, (byte_t*) l_receipt);
pos++;
- uint64_t l_value_send = l_receipt->receipt_info.value_datoshi;
+ uint256_t l_value_send = l_receipt->receipt_info.value_datoshi;
// add 'in_cond' items
dap_chain_datum_tx_t *l_tx_cond = dap_chain_ledger_tx_find_by_hash(l_ledger, a_tx_prev_hash);
@@ -376,10 +381,10 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *
dap_chain_datum_tx_t *l_tx_tmp;
dap_chain_hash_fast_t l_tx_cur_hash = { 0 }; // start hash
dap_chain_tx_out_cond_t *l_tmp_cond;
- uint64_t l_value_cond = 0;
+ uint256_t l_value_cond = {};
int l_tmp_cond_idx;
// Find all transactions
- while (l_value_cond < l_value_send) {
+ while (compare256(l_value_cond, l_value_send) == -1) {
l_tx_tmp = dap_chain_ledger_tx_cache_find_out_cond(l_ledger, &l_tx_cur_hash, &l_tmp_cond, &l_tmp_cond_idx, NULL);
if (!l_tx_tmp) {
break;
@@ -392,18 +397,18 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *
continue;
if (l_tmp_cond->subtype.srv_pay.unit.uint32 != l_out_cond->subtype.srv_pay.unit.uint32)
continue;
- if (l_tmp_cond->subtype.srv_pay.unit_price_max_datoshi != l_out_cond->subtype.srv_pay.unit_price_max_datoshi)
+ if (!EQUAL_256(l_tmp_cond->subtype.srv_pay.unit_price_max_datoshi, l_out_cond->subtype.srv_pay.unit_price_max_datoshi))
continue;
if (memcmp(&l_tmp_cond->subtype.srv_pay.pkey_hash, &l_out_cond->subtype.srv_pay.pkey_hash, sizeof(dap_chain_hash_fast_t)))
continue;
l_value_cond = l_tmp_cond->header.value;
}
- if (l_value_cond < l_value_send) {
+ if (compare256(l_value_cond, l_value_send) == -1) {
log_it(L_WARNING, "Requested conditional transaction is already used out");
return NULL;
}
}
- if (dap_chain_datum_tx_add_in_cond_item(&l_tx, a_tx_prev_hash, l_prev_cond_idx, pos-1) != 0 ){
+ if (dap_chain_datum_tx_add_in_cond_item(&l_tx, a_tx_prev_hash, l_prev_cond_idx, pos - 1) != 0 ){
dap_chain_datum_tx_delete(l_tx);
log_it( L_ERROR, "Cant add tx cond input");
return NULL;
@@ -420,7 +425,7 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *
size_t l_size = dap_chain_datum_item_tx_get_size((uint8_t *)l_out_cond);
dap_chain_tx_out_cond_t *l_out_cond_new = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, l_size);
memcpy(l_out_cond_new, l_out_cond, l_size);
- l_out_cond_new->header.value -= l_value_send;
+ SUBTRACT_256_256(l_out_cond_new->header.value, l_value_send, &l_out_cond_new->header.value);
dap_chain_datum_tx_add_item(&l_tx, (const uint8_t *)l_out_cond_new);
DAP_DELETE(l_out_cond_new);
@@ -467,19 +472,20 @@ static dap_chain_datum_t* dap_chain_tx_create_cond(dap_chain_net_t * a_net,
dap_enc_key_t *a_key_from, dap_enc_key_t *a_key_cond,
const dap_chain_addr_t* a_addr_from,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value,uint64_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
- dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value_fee, const void *a_cond, size_t a_cond_size)
+ uint256_t a_value, uint256_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
+ dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value_fee, const void *a_cond, size_t a_cond_size)
{
dap_ledger_t * l_ledger = a_net ? dap_chain_ledger_by_net_name( a_net->pub.name ) : NULL;
// check valid param
if(!a_net || ! l_ledger || !a_key_from || !a_key_from->priv_key_data || !a_key_from->priv_key_data_size ||
!dap_chain_addr_check_sum(a_addr_from) ||
- !a_value)
+ IS_ZERO_256(a_value))
return NULL;
// find the transactions from which to take away coins
- uint64_t l_value_transfer = 0; // how many coins to transfer
- uint64_t l_value_need = a_value + a_value_fee;
+ uint256_t l_value_transfer = {}; // how many coins to transfer
+ uint256_t l_value_need = {};
+ SUM_256_256(a_value, a_value_fee, &l_value_need);
// list of transaction with 'out' items
dap_list_t *l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(l_ledger, a_token_ticker,
a_addr_from, l_value_need, &l_value_transfer);
@@ -492,24 +498,25 @@ static dap_chain_datum_t* dap_chain_tx_create_cond(dap_chain_net_t * a_net,
dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
// add 'in' items
{
- uint64_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
- assert(l_value_to_items == l_value_transfer);
+ uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
+ assert(EQUAL_256(l_value_to_items, l_value_transfer));
dap_list_free_full(l_list_used_out, free);
}
// add 'out_cond' and 'out' items
{
- uint64_t l_value_pack = 0; // how much coin add to 'out' items
+ uint256_t l_value_pack = {}; // how much coin add to 'out' items
if(dap_chain_datum_tx_add_out_cond_item(&l_tx, a_key_cond, a_srv_uid, a_value, a_value_per_unit_max, a_unit, a_cond,
a_cond_size) == 1) {
- l_value_pack += a_value;
+ SUM_256_256(l_value_pack, a_value, &l_value_pack);
// transaction fee
- if(a_value_fee) {
+ if (!IS_ZERO_256(a_value_fee)) {
// TODO add condition with fee for mempool-as-service
}
}
// coin back
- uint64_t l_value_back = l_value_transfer - l_value_pack;
- if(l_value_back) {
+ uint256_t l_value_back = {};
+ SUBTRACT_256_256(l_value_transfer, l_value_pack, &l_value_back);
+ if (!IS_ZERO_256(l_value_back)) {
if(dap_chain_datum_tx_add_out_item(&l_tx, a_addr_from, l_value_back) != 1) {
dap_chain_datum_tx_delete(l_tx);
log_it( L_ERROR, "Cant add coin back output");
@@ -554,8 +561,8 @@ dap_chain_hash_fast_t* dap_chain_proc_tx_create_cond(dap_chain_net_t * a_net,
dap_enc_key_t *a_key_from, dap_enc_key_t *a_key_cond,
const dap_chain_addr_t* a_addr_from,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value,uint64_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
- dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value_fee, const void *a_cond, size_t a_cond_size)
+ uint256_t a_value, uint256_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
+ dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value_fee, const void *a_cond, size_t a_cond_size)
{
dap_chain_t *l_chain = NULL;
@@ -568,8 +575,8 @@ dap_chain_hash_fast_t* dap_chain_proc_tx_create_cond(dap_chain_net_t * a_net,
return NULL;
// Make transfer transaction
dap_chain_datum_t *l_datum = dap_chain_tx_create_cond(a_net,a_key_from, a_key_cond, a_addr_from,
- a_token_ticker,a_value,a_value_per_unit_max, a_unit,
- a_srv_uid, a_value_fee, a_cond, a_cond_size);
+ a_token_ticker, a_value, a_value_per_unit_max, a_unit,
+ a_srv_uid, a_value_fee, a_cond, a_cond_size);
if(!l_datum)
return NULL;
@@ -596,13 +603,13 @@ dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond(dap_chain_net_t * a_net,
dap_enc_key_t *a_key_from, dap_enc_key_t *a_key_cond,
const dap_chain_addr_t* a_addr_from,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value,uint64_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
- dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value_fee, const void *a_cond, size_t a_cond_size)
+ uint256_t a_value, uint256_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
+ dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value_fee, const void *a_cond, size_t a_cond_size)
{
// Make transfer transaction
- dap_chain_datum_t *l_datum = dap_chain_tx_create_cond(a_net,a_key_from, a_key_cond, a_addr_from,
- a_token_ticker,a_value,a_value_per_unit_max, a_unit,
- a_srv_uid, a_value_fee, a_cond, a_cond_size);
+ dap_chain_datum_t *l_datum = dap_chain_tx_create_cond(a_net, a_key_from, a_key_cond, a_addr_from,
+ a_token_ticker,a_value,a_value_per_unit_max, a_unit,
+ a_srv_uid, a_value_fee, a_cond, a_cond_size);
if(!l_datum)
return NULL;
diff --git a/modules/mempool/include/dap_chain_mempool.h b/modules/mempool/include/dap_chain_mempool.h
index 0e8b0be25b623794efbc28e2576eaf50055ac712..631459d42c9959e90e2884f7b14942945313f5be 100644
--- a/modules/mempool/include/dap_chain_mempool.h
+++ b/modules/mempool/include/dap_chain_mempool.h
@@ -48,27 +48,27 @@ dap_hash_fast_t* dap_chain_mempool_tx_create(dap_chain_t * a_chain, dap_enc_key
const dap_chain_addr_t* a_addr_from, const dap_chain_addr_t* a_addr_to,
const dap_chain_addr_t* a_addr_fee,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value, uint64_t a_value_fee);
+ uint256_t a_value, uint256_t a_value_fee);
// Make transfer transaction & insert to cache
dap_chain_hash_fast_t* dap_chain_proc_tx_create_cond(dap_chain_net_t * a_net,
dap_enc_key_t *a_key_from, dap_enc_key_t *a_key_cond,
const dap_chain_addr_t* a_addr_from,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value,uint64_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
- dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value_fee, const void *a_cond, size_t a_cond_size);
+ uint256_t a_value, uint256_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
+ dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value_fee, const void *a_cond, size_t a_cond_size);
dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond(dap_chain_net_t * a_net,
dap_enc_key_t *a_key_from, dap_enc_key_t *a_key_cond,
const dap_chain_addr_t* a_addr_from,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value,uint64_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
- dap_chain_net_srv_uid_t a_srv_uid, uint64_t a_value_fee, const void *a_cond, size_t a_cond_size);
+ uint256_t a_value, uint256_t a_value_per_unit_max, dap_chain_net_srv_price_unit_uid_t a_unit,
+ dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value_fee, const void *a_cond, size_t a_cond_size);
dap_chain_hash_fast_t* dap_chain_mempool_tx_create_cond_input(dap_chain_net_t * a_net,dap_chain_hash_fast_t *a_tx_prev_hash,
const dap_chain_addr_t* a_addr_to, dap_enc_key_t * l_key_tx_sign, dap_chain_datum_tx_receipt_t * l_receipt, size_t l_receipt_size);
-int dap_chain_mempool_tx_create_massive( dap_chain_t * a_chain, dap_enc_key_t *a_key_from,
+int dap_chain_mempool_tx_create_massive(dap_chain_t * a_chain, dap_enc_key_t *a_key_from,
const dap_chain_addr_t* a_addr_from, const dap_chain_addr_t* a_addr_to,
const dap_chain_addr_t* a_addr_fee,
const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint64_t a_value, uint64_t a_value_fee,size_t a_tx_num);
+ uint256_t a_value, uint256_t a_value_fee, size_t a_tx_num);
diff --git a/modules/mining/CMakeLists.txt b/modules/mining/CMakeLists.txt
index 5950015428d51b7a2359c33fdfe4241b75508844..3967079cb0bf22b50675a75a753d6ad6c5aa0877 100644
--- a/modules/mining/CMakeLists.txt
+++ b/modules/mining/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_crypto)
file(GLOB DAP_CHAIN_CRYPTO_SRCS *.c)
diff --git a/modules/modules_dynamic/cdb/CMakeLists.txt b/modules/modules_dynamic/cdb/CMakeLists.txt
index 1d2ef0120fe05ab073c64c7229dd8e57c2c03aa0..7a387d86a55e76e2ffcf8b6915bcf81ba27a3c4b 100644
--- a/modules/modules_dynamic/cdb/CMakeLists.txt
+++ b/modules/modules_dynamic/cdb/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_modules_dynamic_cdb)
file(GLOB DAP_MODULES_DYNAMIC_CDB_SRCS *.c)
diff --git a/modules/modules_dynamic/cdb/dap_modules_dynamic_cdb.c b/modules/modules_dynamic/cdb/dap_modules_dynamic_cdb.c
index fadef7066e975c03cb7ddbc0dd89d6eb446283cb..b4e8130de195b9c6cd04d81be978001d129ed71b 100644
--- a/modules/modules_dynamic/cdb/dap_modules_dynamic_cdb.c
+++ b/modules/modules_dynamic/cdb/dap_modules_dynamic_cdb.c
@@ -29,10 +29,11 @@
#include <dlfcn.h>
#endif
-#define LOG_TAG "dap_http"
+#define LOG_TAG "dap_modules_dynamic"
static const char * s_default_path_modules = "var/modules";
static void *s_cdb_handle = NULL;
+static bool s_cdb_was_init = false;
void dap_modules_dynamic_close_cdb()
{
@@ -40,10 +41,13 @@ void dap_modules_dynamic_close_cdb()
dlclose(s_cdb_handle);
s_cdb_handle = NULL;
}
+ s_cdb_was_init = false;
}
void *dap_modules_dynamic_get_cdb_func(const char *a_func_name)
{
+ if (!s_cdb_was_init)
+ return NULL;
char l_lib_path[MAX_PATH] = {'\0'};
void *l_ref_func = NULL;
// find func from dynamic library
@@ -73,16 +77,20 @@ void *dap_modules_dynamic_get_cdb_func(const char *a_func_name)
int dap_modules_dynamic_load_cdb(dap_http_t * a_server)
{
+ s_cdb_was_init = true;
int (*dap_chain_net_srv_vpn_cdb_init)(dap_http_t *);
dap_chain_net_srv_vpn_cdb_init = dap_modules_dynamic_get_cdb_func("dap_chain_net_srv_vpn_cdb_init");
if (!dap_chain_net_srv_vpn_cdb_init) {
- log_it(L_ERROR,"dap_modules_dynamic: can't load dap_chain_net_srv_vpn_cdb_init");
+ s_cdb_was_init = false;
+ log_it(L_ERROR, "dap_modules_dynamic: dap_chain_net_srv_vpn_cdb_init not found");
return -2;
}
int l_init_res = dap_chain_net_srv_vpn_cdb_init(a_server);
if (l_init_res) {
- log_it(L_ERROR,"dap_modules_dynamic: dap_chain_net_srv_vpn_cdb_init returns %d", l_init_res);
+ s_cdb_was_init = false;
+ log_it(L_ERROR, "dap_modules_dynamic: dap_chain_net_srv_vpn_cdb_init returns %d", l_init_res);
return -3;
}
+ s_cdb_was_init = true;
return 0;
}
diff --git a/modules/net/CMakeLists.txt b/modules/net/CMakeLists.txt
index 4c05cea61e5af5c5a8710ee0c20c5a9904af0c74..f4ccdaff3953e4c8bc9d6be53701ac60e6ac1b13 100644
--- a/modules/net/CMakeLists.txt
+++ b/modules/net/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net)
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index ac3dbf15c4ef6ae3f5a052ae48b077c7fcdcb362..b1f8162a3afa528da2c5799ec9dd37159bc69878 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -144,6 +144,8 @@ typedef struct dap_chain_net_pvt{
dap_chain_node_addr_t * node_addr;
dap_chain_node_info_t * node_info; // Current node's info
+ //Active synchronizing link
+ dap_chain_node_client_t *active_link;
// Established links
dap_list_t *links; // Links list
size_t links_connected_count;
@@ -255,7 +257,61 @@ static uint8_t *dap_chain_net_set_acl(dap_chain_hash_fast_t *a_pkey_hash);
static dap_global_db_obj_callback_notify_t s_srv_callback_notify = NULL;
+/**
+ * @brief
+ * init network settings from cellrame-node.cfg file
+ * register net* commands in cellframe-node-cli interface
+ * @return
+ */
+int dap_chain_net_init()
+{
+ dap_stream_ch_chain_init();
+ dap_stream_ch_chain_net_init();
+ dap_chain_node_client_init();
+ dap_chain_node_cli_cmd_item_create ("net", s_cli_net, "Network commands",
+ "net list [chains -n <chain net name>]"
+ "\tList all networks or list all chains in selected network"
+ "net -net <chain net name> [-mode {update | all}] go {online | offline | sync}\n"
+ "\tFind and establish links and stay online. \n"
+ "\tMode \"update\" is by default when only new chains and gdb are updated. Mode \"all\" updates everything from zero\n"
+ "net -net <chain net name> get status\n"
+ "\tLook at current status\n"
+ "net -net <chain net name> stats tx [-from <From time>] [-to <To time>] [-prev_sec <Seconds>] \n"
+ "\tTransactions statistics. Time format is <Year>-<Month>-<Day>_<Hours>:<Minutes>:<Seconds> or just <Seconds> \n"
+ "net -net <chain net name> [-mode {update | all}] sync {all | gdb | chains}\n"
+ "\tSyncronyze gdb, chains or everything\n"
+ "\tMode \"update\" is by default when only new chains and gdb are updated. Mode \"all\" updates everything from zero\n"
+ "net -net <chain net name> link {list | add | del | info | establish}\n"
+ "\tList, add, del, dump or establish links\n"
+ "net -net <chain net name> ca add {-cert <cert name> | -hash <cert hash>}\n"
+ "\tAdd certificate to list of authority cetificates in GDB group\n"
+ "net -net <chain net name> ca list\n"
+ "\tPrint list of authority cetificates from GDB group\n"
+ "net -net <chain net name> ca del -hash <cert hash> [-H hex|base58(default)]\n"
+ "\tDelete certificate from list of authority cetificates in GDB group by it's hash\n"
+ "net -net <chain net name> ledger reload\n"
+ "\tPurge the cache of chain net ledger and recalculate it from chain file\n");
+ s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
+ // maximum number of connections to other nodes
+ s_max_links_count = dap_config_get_item_int32_default(g_config, "general", "max_links", s_max_links_count);
+ // required number of connections to other nodes
+ s_required_links_count = dap_config_get_item_int32_default(g_config, "general", "require_links", s_required_links_count);
+ s_debug_more = dap_config_get_item_bool_default(g_config,"chain_net","debug_more",false);
+
+ dap_chain_net_load_all();
+
+ dap_enc_http_set_acl_callback(dap_chain_net_set_acl);
+ log_it(L_NOTICE,"Chain networks initialized");
+ return 0;
+}
+
+/**
+ * @brief get certificate hash from chain config [acl_accept_ca_gdb] param
+ *
+ * @param a_net dap_chain_net_t chain object
+ * @return char*
+ */
char *dap_chain_net_get_gdb_group_acl(dap_chain_net_t *a_net)
{
if (a_net) {
@@ -273,9 +329,10 @@ char *dap_chain_net_get_gdb_group_acl(dap_chain_net_t *a_net)
}
/**
- * @brief s_net_state_to_str
- * @param l_state
- * @return
+ * @brief convert dap_chain_net_state_t net state object to string
+ *
+ * @param l_state dap_chain_net_state_t
+ * @return const char*
*/
inline static const char * s_net_state_to_str(dap_chain_net_state_t l_state)
{
@@ -283,9 +340,11 @@ inline static const char * s_net_state_to_str(dap_chain_net_state_t l_state)
}
/**
- * @brief dap_chain_net_state_go_to
- * @param a_net
- * @param a_new_state
+ * @brief set current network state to F_DAP_CHAIN_NET_GO_SYNC
+ *
+ * @param a_net dap_chain_net_t network object
+ * @param a_new_state dap_chain_net_state_t new network state
+ * @return int
*/
int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_new_state)
{
@@ -297,7 +356,7 @@ int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_n
pthread_mutex_lock( &PVT(a_net)->state_mutex_cond); // Preventing call of state_go_to before wait cond will be armed
// set flag for sync
PVT(a_net)->flags |= F_DAP_CHAIN_NET_GO_SYNC;
- PVT(a_net)->flags |= F_DAP_CHAIN_NET_SYNC_FROM_ZERO;
+ //PVT(a_net)->flags |= F_DAP_CHAIN_NET_SYNC_FROM_ZERO; // TODO set this flag according to -mode argument from command line
#ifndef _WIN32
pthread_cond_signal( &PVT(a_net)->state_proc_cond );
#else
@@ -308,12 +367,31 @@ int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_n
return 0;
}
+dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t *a_net)
+{
+ return PVT(a_net)->state_target;
+}
+/**
+ * @brief set s_srv_callback_notify
+ *
+ * @param a_callback dap_global_db_obj_callback_notify_t callback function
+ */
void dap_chain_net_set_srv_callback_notify(dap_global_db_obj_callback_notify_t a_callback)
{
s_srv_callback_notify = a_callback;
}
+/**
+ * @brief if current network in ONLINE state send to all connected node
+ * executes, when you add data to gdb chain (class=gdb in chain config)
+ * @param a_arg arguments. Can be network object (dap_chain_net_t)
+ * @param a_op_code object type (f.e. l_net->type from dap_store_obj)
+ * @param a_group group, for example "chain-gdb.home21-network.chain-F"
+ * @param a_key key hex value, f.e. 0x12EFA084271BAA5EEE93B988E73444B76B4DF5F63DADA4B300B051E29C2F93
+ * @param a_value buffer with data
+ * @param a_value_len buffer size
+ */
void dap_chain_net_sync_gdb_broadcast(void *a_arg, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_len)
{
@@ -341,13 +419,13 @@ void dap_chain_net_sync_gdb_broadcast(void *a_arg, const char a_op_code, const c
dap_store_obj_pkt_t *l_data_out = dap_store_packet_single(l_obj);
dap_store_obj_free(l_obj, 1);
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){};
+ dap_chain_id_t l_chain_id = l_chain ? l_chain->id : (dap_chain_id_t) {};
dap_chain_cell_id_t l_cell_id = l_chain ? l_chain->cells->id : (dap_chain_cell_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;
dap_stream_worker_t *l_stream_worker = dap_client_get_stream_worker(l_node_client->client);
- if (l_stream_worker)
+ if (!l_stream_worker)
continue;
dap_stream_ch_chain_pkt_write_mt(l_stream_worker, l_node_client->ch_chain_uuid, DAP_STREAM_CH_CHAIN_PKT_TYPE_GLOBAL_DB, l_net->pub.id.uint64,
l_chain_id.uint64, l_cell_id.uint64, l_data_out,
@@ -359,14 +437,14 @@ void dap_chain_net_sync_gdb_broadcast(void *a_arg, const char a_op_code, const c
}
/**
- * @brief s_gbd_history_callback_notify
- * @param a_arg
- * @param a_op_code
- * @param a_prefix
- * @param a_group
- * @param a_key
- * @param a_value
- * @param a_value_len
+ * @brief added like callback in dap_chain_global_db_add_sync_group
+ *
+ * @param a_arg arguments. Can be network object (dap_chain_net_t)
+ * @param a_op_code object type (f.e. l_net->type from dap_store_obj)
+ * @param a_group group, for example "chain-gdb.home21-network.chain-F"
+ * @param a_key key hex value, f.e. 0x12EFA084271BAA5EEE93B988E73444B76B4DF5F63DADA4B300B051E29C2F93
+ * @param a_value buffer with data
+ * @param a_value_len buffer size
*/
static void s_gbd_history_callback_notify (void * a_arg, const char a_op_code, const char * a_group,
const char * a_key, const void * a_value, const size_t a_value_len)
@@ -458,16 +536,13 @@ static void s_node_link_callback_connected(dap_chain_node_client_t * a_node_clie
}
a_node_client->resync_gdb = l_net_pvt->flags & F_DAP_CHAIN_NET_SYNC_FROM_ZERO;
- if (!a_node_client->is_reconnecting) {
- if ( s_debug_more )
- log_it(L_NOTICE, "Established connection with %s."NODE_ADDR_FP_STR,l_net->pub.name,
- NODE_ADDR_FP_ARGS_S(a_node_client->remote_node_addr));
- pthread_rwlock_wrlock(&l_net_pvt->rwlock);
- l_net_pvt->links = dap_list_append(l_net_pvt->links, a_node_client);
- l_net_pvt->links_connected_count++;
- s_net_links_notify(l_net);
- }
-
+ if ( s_debug_more )
+ log_it(L_NOTICE, "Established connection with %s."NODE_ADDR_FP_STR,l_net->pub.name,
+ NODE_ADDR_FP_ARGS_S(a_node_client->remote_node_addr));
+ pthread_rwlock_wrlock(&l_net_pvt->rwlock);
+ l_net_pvt->links_connected_count++;
+ a_node_client->is_connected = true;
+ s_net_links_notify(l_net);
if(l_net_pvt->state == NET_STATE_LINKS_CONNECTING ){
l_net_pvt->state = NET_STATE_LINKS_ESTABLISHED;
dap_proc_queue_add_callback_inter(a_node_client->stream_worker->worker->proc_queue_input,s_net_states_proc,l_net );
@@ -486,25 +561,18 @@ static void s_node_link_callback_disconnected(dap_chain_node_client_t * a_node_c
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 ( l_net_pvt->state_target ==NET_STATE_ONLINE ){
- if(s_debug_more)
- log_it(L_NOTICE, "%s."NODE_ADDR_FP_STR" disconnected, reconnecting back...",
- l_net->pub.name,
- NODE_ADDR_FP_ARGS_S(a_node_client->remote_node_addr) );
- a_node_client->is_reconnecting = true;
- dap_chain_net_client_create_n_connect(l_net, a_node_client->info);
- }else if (l_net_pvt->state_target == NET_STATE_OFFLINE){
- if(l_net_pvt->links_connected_count) {
- s_node_link_callback_delete(a_node_client,a_arg);
+ 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...");
+ if (l_net_pvt->links_connected_count)
l_net_pvt->links_connected_count--;
- } else
- log_it(L_CRITICAL,"Links count is zero in disconnected callback, looks smbd decreased it twice or forget to increase on connect/reconnect");
- log_it(L_INFO, "%s."NODE_ADDR_FP_STR" disconnected",l_net->pub.name,NODE_ADDR_FP_ARGS_S(a_node_client->info->hdr.address));
-
- }else{
- log_it(L_CRITICAL,"Link "NODE_ADDR_FP_STR" disconnected, but wrong target state %s: could be only NET_STATE_ONLINE or NET_STATE_OFFLINE "
- ,NODE_ADDR_FP_ARGS_S(a_node_client->remote_node_addr)
- , c_net_states[l_net_pvt->state_target] );
+ 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;
}
pthread_rwlock_unlock(&l_net_pvt->rwlock);
}
@@ -755,7 +823,6 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
assert(l_net_pvt);
if (l_net_pvt->state_target == NET_STATE_OFFLINE) {
l_net_pvt->state = NET_STATE_OFFLINE;
- return true;
}
pthread_rwlock_wrlock(&l_net_pvt->rwlock);
@@ -912,16 +979,18 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
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;
- (void) dap_chain_net_client_create_n_connect(l_net,l_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)
+ break;
}
} break;
+
case NET_STATE_LINKS_ESTABLISHED:{
log_it(L_INFO,"%s.state: NET_STATE_LINKS_ESTABLISHED", l_net->pub.name);
- for (dap_list_t *l_tmp = l_net_pvt->links ; l_tmp; l_tmp = dap_list_next(l_tmp)) {
- //dap_chain_node_client_t *l_link = (dap_chain_node_client_t *)l_tmp->data;
- //
- }
}break;
+
case NET_STATE_SYNC_GDB :{
log_it(L_INFO,"%s.state: NET_STATE_SYNC_GDB", l_net->pub.name);
}break;
@@ -930,11 +999,11 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
log_it(L_INFO,"%s.state: NET_STATE_SYNC_CHAINS", l_net->pub.name);
}break;
-
case NET_STATE_ONLINE: {
log_it(L_NOTICE,"%s.state: NET_STATE_ONLINE", l_net->pub.name);
}
break;
+
default: log_it (L_DEBUG, "Unprocessed state");
}
s_net_states_notify(l_net);
@@ -942,6 +1011,38 @@ static bool s_net_states_proc(dap_proc_thread_t *a_thread, void *a_arg)
return ! l_repeat_after_exit;
}
+
+bool dap_chain_net_sync_trylock(dap_chain_net_t *a_net, dap_chain_node_client_t *a_client)
+{
+ dap_chain_net_pvt_t *l_net_pvt = PVT(a_net);
+ 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 &&
+ l_client->state < NODE_CLIENT_STATE_SYNCED) {
+ l_found = true;
+ break;
+ }
+ }
+ }
+ }
+ if (!l_found) {
+ l_net_pvt->active_link = a_client;
+ }
+ pthread_rwlock_unlock(&l_net_pvt->rwlock);
+ return !l_found;
+}
+
+void dap_chain_net_sync_unlock(dap_chain_net_t *a_net)
+{
+ dap_chain_net_pvt_t *l_net_pvt = PVT(a_net);
+ pthread_rwlock_rdlock(&l_net_pvt->rwlock);
+ l_net_pvt->active_link = NULL;
+ pthread_rwlock_unlock(&l_net_pvt->rwlock);
+}
/**
* @brief dap_chain_net_client_create_n_connect
* @param a_net
@@ -987,6 +1088,8 @@ dap_chain_node_role_t dap_chain_net_get_role(dap_chain_net_t * a_net)
static dap_chain_net_t *s_net_new(const char * a_id, const char * a_name ,
const char * a_node_role)
{
+ if (!a_id || !a_name || !a_node_role)
+ return NULL;
dap_chain_net_t *ret = DAP_NEW_Z_SIZE( dap_chain_net_t, sizeof(ret->pub) + sizeof(dap_chain_net_pvt_t) );
ret->pub.name = strdup( a_name );
@@ -1058,56 +1161,6 @@ void dap_chain_net_delete( dap_chain_net_t * a_net )
}
-/**
- * @brief
- * init network settings from cellrame-node.cfg file
- * register net* commands in cellframe-node-cli interface
- * @return
- */
-int dap_chain_net_init()
-{
- dap_stream_ch_chain_init();
- dap_stream_ch_chain_net_init();
-
- dap_chain_node_client_init();
- dap_chain_node_cli_cmd_item_create ("net", s_cli_net, "Network commands",
- "net list [chains -n <chain net name>]"
- "\tList all networks or list all chains in selected network"
- "net -net <chain net name> [-mode update|all] go < online | offline >\n"
- "\tFind and establish links and stay online. \n"
- "\tMode \"update\" is by default when only new chains and gdb are updated. Mode \"all\" updates everything from zero\n"
- "net -net <chain net name> get status\n"
- "\tLook at current status\n"
- "net -net <chain net name> stats tx [-from <From time>] [-to <To time>] [-prev_sec <Seconds>] \n"
- "\tTransactions statistics. Time format is <Year>-<Month>-<Day>_<Hours>:<Minutes>:<Seconds> or just <Seconds> \n"
- "net -net <chain net name> [-mode update|all] sync < all | gdb | chains >\n"
- "\tSyncronyze gdb, chains or everything\n"
- "\tMode \"update\" is by default when only new chains and gdb are updated. Mode \"all\" updates everything from zero\n"
- "net -net <chain net name> link < list | add | del | info | establish >\n"
- "\tList, add, del, dump or establish links\n"
- "net -net <chain net name> ca add {-cert <cert name> | -hash <cert hash>}\n"
- "\tAdd certificate to list of authority cetificates in GDB group\n"
- "net -net <chain net name> ca list\n"
- "\tPrint list of authority cetificates from GDB group\n"
- "net -net <chain net name> ca del -hash <cert hash> [-H hex|base58(default)]\n"
- "\tDelete certificate from list of authority cetificates in GDB group by it's hash\n"
- "net -net <chain net name> ledger reload\n"
- "\tPurge the cache of chain net ledger and recalculate it from chain file\n" );
- s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
-
- // maximum number of connections to other nodes
- s_max_links_count = dap_config_get_item_int32_default(g_config, "general", "max_links", s_max_links_count);
- // required number of connections to other nodes
- s_required_links_count = dap_config_get_item_int32_default(g_config, "general", "require_links", s_required_links_count);
- s_debug_more = dap_config_get_item_bool_default(g_config,"chain_net","debug_more",false);
-
- dap_chain_net_load_all();
-
- dap_enc_http_set_acl_callback(dap_chain_net_set_acl);
- log_it(L_NOTICE,"Chain networks initialized");
- return 0;
-}
-
/**
* @brief
* load network config settings
@@ -1166,8 +1219,8 @@ void s_set_reply_text_node_status(char **a_str_reply, dap_chain_net_t * a_net){
char* l_sync_current_link_text_block = NULL;
if (PVT(a_net)->state != NET_STATE_OFFLINE)
l_sync_current_link_text_block = dap_strdup_printf(", active links %u from %u",
- dap_list_length(PVT(a_net)->links),
- dap_list_length(PVT(a_net)->links_info));
+ PVT(a_net)->links_connected_count,
+ dap_list_length(PVT(a_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],
@@ -1205,18 +1258,17 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
// command 'list'
const char * l_list_cmd = NULL;
- if(dap_chain_node_cli_find_option_val(argv, arg_index, argc, "list", &l_list_cmd) != 0 ) {
+ if(dap_chain_node_cli_find_option_val(argv, arg_index, min(argc, arg_index + 1), "list", &l_list_cmd) != 0 ) {
dap_string_t *l_string_ret = dap_string_new("");
if (dap_strcmp(l_list_cmd,"chains")==0){
const char * l_net_str = NULL;
dap_chain_net_t* l_net = NULL;
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-net", &l_net_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "--net", &l_net_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-n", &l_net_str);
+
l_net = dap_chain_net_by_name(l_net_str);
if (l_net){
- dap_string_append(l_string_ret,"Chains:\n ");
+ dap_string_append(l_string_ret,"Chains:\n");
dap_chain_t * l_chain = l_net->pub.chains;
while (l_chain) {
dap_string_append_printf(l_string_ret, "\t%s:\n", l_chain->name );
@@ -1225,7 +1277,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
}else{
dap_chain_net_item_t * l_net_item, *l_net_item_tmp;
int l_net_i = 0;
- dap_string_append(l_string_ret,"Networks:\n ");
+ dap_string_append(l_string_ret,"Networks:\n");
HASH_ITER(hh, s_net_items, l_net_item, l_net_item_tmp){
l_net = l_net_item->chain_net;
dap_string_append_printf(l_string_ret, "\t%s:\n", l_net_item->name);
@@ -1240,12 +1292,12 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
}
}else{
- dap_string_append(l_string_ret,"Networks:\n ");
+ dap_string_append(l_string_ret,"Networks:\n");
// show list of nets
dap_chain_net_item_t * l_net_item, *l_net_item_tmp;
int l_net_i = 0;
HASH_ITER(hh, s_net_items, l_net_item, l_net_item_tmp){
- dap_string_append_printf(l_string_ret, "%s\n", l_net_item->name);
+ dap_string_append_printf(l_string_ret, "\t%s\n", l_net_item->name);
l_net_i++;
}
dap_string_append(l_string_ret, "\n");
@@ -1359,7 +1411,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
else if(strcmp(l_go_str, "sync") == 0) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Network \"%s\" resynchronizing",
l_net->pub.name);
- dap_chain_net_state_go_to(l_net, NET_STATE_SYNC_GDB);
+ dap_chain_net_state_go_to(l_net, NET_STATE_SYNC_CHAINS);
}
} else if ( l_get_str){
@@ -1438,6 +1490,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply,
"SYNC_CHAINS state requested to state machine. Current state: %s\n",
c_net_states[ PVT(l_net)->state] );
+ // TODO set PVT flag to exclude GDB sync
dap_chain_net_sync_chains(l_net);
} else {
@@ -1549,7 +1602,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
ret = -5;
}
} else if (l_ledger_str && !strcmp(l_ledger_str, "reload")) {
- dap_chain_ledger_purge(l_net->pub.ledger);
+ dap_chain_ledger_purge(l_net->pub.ledger, false);
dap_chain_t *l_chain;
DL_FOREACH(l_net->pub.chains, l_chain) {
if (l_chain->callback_purge) {
@@ -1613,11 +1666,11 @@ int s_net_load(const char * a_net_name, uint16_t a_acl_idx)
dap_config_get_item_str(l_cfg , "general" , "name" ),
dap_config_get_item_str(l_cfg , "general" , "node-role" )
);
- dap_chain_net_pvt_t * l_net_pvt = PVT(l_net);
if(!l_net) {
log_it(L_ERROR,"Can't create l_net");
return -1;
}
+ dap_chain_net_pvt_t * l_net_pvt = PVT(l_net);
l_net_pvt->load_mode = true;
l_net_pvt->acl_idx = a_acl_idx;
l_net->pub.gdb_groups_prefix = dap_strdup (
@@ -1695,7 +1748,6 @@ int s_net_load(const char * a_net_name, uint16_t a_acl_idx)
case NODE_ROLE_ROOT_MASTER:
case NODE_ROLE_ROOT:
case NODE_ROLE_ARCHIVE:
- l_ledger_flags |= DAP_CHAIN_LEDGER_CHECK_TOKEN_EMISSION;
case NODE_ROLE_MASTER:
l_ledger_flags |= DAP_CHAIN_LEDGER_CHECK_CELLS_DS;
case NODE_ROLE_CELL_MASTER:
@@ -2094,6 +2146,7 @@ int s_net_load(const char * a_net_name, uint16_t a_acl_idx)
l_target_state = NET_STATE_OFFLINE;
}
l_net_pvt->load_mode = false;
+ dap_chain_ledger_load_end(l_net->pub.ledger);
if (l_target_state != l_net_pvt->state_target)
dap_chain_net_state_go_to(l_net, l_target_state);
@@ -2543,23 +2596,12 @@ int dap_chain_net_verify_datum_for_add(dap_chain_net_t *a_net, dap_chain_datum_t
return -11;
switch ( a_datum->header.type_id) {
- case DAP_CHAIN_DATUM_256_TX: // 256
case DAP_CHAIN_DATUM_TX:
- return dap_chain_ledger_tx_add_check( a_net->pub.ledger,
- (dap_chain_datum_tx_t*) a_datum->data );
-
- case DAP_CHAIN_DATUM_256_TOKEN_DECL: // 256
+ return dap_chain_ledger_tx_add_check( a_net->pub.ledger, (dap_chain_datum_tx_t*)a_datum->data );
case DAP_CHAIN_DATUM_TOKEN_DECL:
- return dap_chain_ledger_token_decl_add_check( a_net->pub.ledger,
- (dap_chain_datum_token_t*) a_datum->data );
-
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
- case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) a_datum->data;
- // l_token_em->hdr.type_value_256 = a_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- // true : false;
- return dap_chain_ledger_token_emission_add_check( a_net->pub.ledger, (dap_chain_datum_token_emission_t*) a_datum->data, a_datum->header.data_size );
- }
+ return dap_chain_ledger_token_decl_add_check( a_net->pub.ledger, (dap_chain_datum_token_t *)a_datum->data);
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION:
+ return dap_chain_ledger_token_emission_add_check( a_net->pub.ledger, a_datum->data, a_datum->header.data_size );
default: return 0;
}
}
@@ -2573,17 +2615,16 @@ int dap_chain_net_verify_datum_for_add(dap_chain_net_t *a_net, dap_chain_datum_t
* @param a_str_out
* @param a_datum
*/
-void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_datum, const char *a_hash_out_type)
+void dap_chain_net_dump_datum(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, const char *a_hash_out_type)
{
if( a_datum == NULL){
dap_string_append_printf(a_str_out,"==Datum is NULL\n");
return;
}
switch (a_datum->header.type_id){
- case DAP_CHAIN_DATUM_256_TOKEN_DECL:
case DAP_CHAIN_DATUM_TOKEN_DECL:{
- dap_chain_datum_token_t * l_token = (dap_chain_datum_token_t*) a_datum->data;
size_t l_token_size = a_datum->header.data_size;
+ dap_chain_datum_token_t * l_token = dap_chain_datum_token_read(a_datum->data, &l_token_size);
if(l_token_size < sizeof(dap_chain_datum_token_t)){
dap_string_append_printf(a_str_out,"==Datum has incorrect size. Only %zu, while at least %zu is expected\n",
l_token_size, sizeof(dap_chain_datum_token_t));
@@ -2602,7 +2643,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_string_append_printf(a_str_out, "total_supply: %"DAP_UINT64_FORMAT_U"\n", l_token->header_private.total_supply );
else
dap_string_append_printf(a_str_out, "total_supply: %s\n",
- dap_chain_u256tostr(l_token->header_private.total_supply_256));
+ dap_chain_balance_print(l_token->header_private.total_supply_256));
}break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:{
@@ -2632,13 +2673,13 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: // 256
dap_string_append_printf(a_str_out,"total_supply: %s\n",
- dap_chain_u256tostr(
+ dap_chain_balance_print(
dap_tsd_get_scalar(l_tsd, uint256_t)));
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: // 128
dap_string_append_printf(a_str_out,"total_supply: %s\n",
- dap_chain_balance_print(
- dap_tsd_get_scalar(l_tsd, uint128_t)));
+ dap_chain_balance_print(GET_256_FROM_128(
+ dap_tsd_get_scalar(l_tsd, uint128_t))));
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID :
dap_string_append_printf(a_str_out,"total_signs_valid: %u\n",
@@ -2744,13 +2785,13 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
switch( l_tsd->type){
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: // 256
dap_string_append_printf(a_str_out,"total_supply: %s\n",
- dap_chain_u256tostr(
+ dap_chain_balance_print(
dap_tsd_get_scalar(l_tsd, uint256_t)));
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: // 128
dap_string_append_printf(a_str_out,"total_supply: %s\n",
- dap_chain_balance_print(
- dap_tsd_get_scalar(l_tsd, uint128_t)));
+ dap_chain_balance_print(GET_256_FROM_128(
+ dap_tsd_get_scalar(l_tsd, uint128_t))));
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID :
dap_string_append_printf(a_str_out,"total_signs_valid: %u\n",
@@ -2790,7 +2831,6 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
size_t l_certs_field_size = l_token_size - sizeof(*l_token) - l_token->header_private_decl.tsd_total_size;
dap_chain_datum_token_certs_dump(a_str_out, l_token->data_n_tsd, l_certs_field_size);
}break;
- case DAP_CHAIN_DATUM_256_TX:
case DAP_CHAIN_DATUM_TX:{
dap_chain_datum_tx_t * l_tx =(dap_chain_datum_tx_t *) a_datum->data;
char buf[50];
@@ -2816,9 +2856,9 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_hash_fast_to_str(&l_in->header.tx_prev_hash, l_tx_prev_hash_str, sizeof (l_tx_prev_hash_str)-1);
dap_string_append_printf(a_str_out,"\ttx_prev_hash : %s\n", l_tx_prev_hash_str );
} break;
- case TX_ITEM_TYPE_256_OUT: { // 256
+ case TX_ITEM_TYPE_OUT_256: { // 256
dap_string_append_printf(a_str_out,"\tvalue: %s\n",
- dap_chain_u256tostr(((dap_chain_256_tx_out_t *)l_cur->data)->header.value)
+ dap_chain_balance_print(((dap_chain_256_tx_out_t *)l_cur->data)->header.value)
);
char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_256_tx_out_t *)l_cur->data)->addr );
dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
@@ -2832,20 +2872,9 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
DAP_DELETE(l_addr_str);
} break;
- case TX_ITEM_TYPE_256_OUT_EXT: { // 256
- // dap_chain_256_tx_out_ext_t * l_out_ext = l_cur->data;
+ case TX_ITEM_TYPE_OUT_EXT: { // 256
dap_string_append_printf(a_str_out,"\tvalue: %s\n",
- dap_chain_u256tostr(((dap_chain_256_tx_out_ext_t *)l_cur->data)->header.value)
- );
- char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_256_tx_out_ext_t *)l_cur->data)->addr );
- dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
- dap_string_append_printf(a_str_out,"\ttoken : %s\n", ((dap_chain_256_tx_out_ext_t *)l_cur->data)->token );
- DAP_DELETE(l_addr_str);
- } break;
- case TX_ITEM_TYPE_OUT_EXT:{
- // dap_chain_tx_out_ext_t * l_out_ext = l_cur->data;
- dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n",
- ((dap_chain_tx_out_ext_t *)l_cur->data)->header.value
+ dap_chain_balance_print(((dap_chain_tx_out_ext_t *)l_cur->data)->header.value)
);
char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_tx_out_ext_t *)l_cur->data)->addr );
dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
@@ -2863,7 +2892,6 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_hash_fast_to_str(&l_sign_hash,l_sign_hash_str,sizeof (l_sign_hash_str)-1);
dap_string_append_printf(a_str_out,"\tpkey_hash: %s\n", l_sign_hash_str );
} break;
- case TX_ITEM_TYPE_256_TOKEN: // 256
case TX_ITEM_TYPE_TOKEN:{
dap_chain_tx_token_t * l_token = l_cur->data;
dap_string_append_printf(a_str_out,"\tticker: %s\n", l_token->header.ticker );
@@ -2873,7 +2901,6 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
sizeof (l_token_emission_hash_str)-1);
dap_string_append_printf(a_str_out,"\ttoken_emission_hash: %s", l_token_emission_hash_str );
} break;
- case TX_ITEM_TYPE_256_TOKEN_EXT: // 256
case TX_ITEM_TYPE_TOKEN_EXT:{
dap_chain_tx_token_ext_t * l_token = l_cur->data;
dap_string_append_printf(a_str_out,"\tversion: %u\n",l_token->header.version );
@@ -2894,9 +2921,9 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_hash_fast_to_str(&l_in->header.tx_prev_hash, l_tx_prev_hash_str,sizeof (l_tx_prev_hash_str)-1);
dap_string_append_printf(a_str_out,"\ttx_prev_hash : %s\n", l_tx_prev_hash_str );
} break;
- case TX_ITEM_TYPE_256_OUT_COND: { // 256
- dap_chain_256_tx_out_cond_t * l_out = l_cur->data;
- dap_string_append_printf(a_str_out,"\tvalue: %s\n", dap_chain_u256tostr(l_out->header.value) );
+ case TX_ITEM_TYPE_OUT_256_COND: { // 256
+ dap_chain_tx_out_cond_t * l_out = l_cur->data;
+ dap_string_append_printf(a_str_out,"\tvalue: %s\n", dap_chain_balance_print(l_out->header.value) );
switch ( l_out->header.subtype){
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:{
dap_string_append_printf(a_str_out,"\tsubtype: DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY\n");
@@ -2911,7 +2938,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
default: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_UNKNOWN\n"); break;
}
dap_string_append_printf(a_str_out,"\tunit_price_max: %s\n",
- dap_chain_u256tostr(l_out->subtype.srv_pay.unit_price_max_datoshi)
+ dap_chain_balance_print(l_out->subtype.srv_pay.unit_price_max_datoshi)
);
char l_pkey_hash_str[70]={[0]='\0'};
dap_chain_hash_fast_to_str(&l_out->subtype.srv_pay.pkey_hash, l_pkey_hash_str, sizeof (l_pkey_hash_str)-1);
@@ -2930,7 +2957,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_string_append_printf(a_str_out,"\tparams_size : %u\n", l_out->params_size );
} break;
case TX_ITEM_TYPE_OUT_COND:{
- dap_chain_tx_out_cond_t * l_out = l_cur->data;
+ dap_chain_tx_out_cond_old_t * l_out = l_cur->data;
dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n", l_out->header.value );
switch ( l_out->header.subtype){
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:{
@@ -2946,9 +2973,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
default: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_UNKNOWN\n"); break;
}
dap_string_append_printf(a_str_out,"\tunit_price_max: %"DAP_UINT64_FORMAT_U"\n",
- l_out->subtype.srv_pay.unit_price_max_datoshi
- );
-
+ l_out->subtype.srv_pay.unit_price_max_datoshi);
char l_pkey_hash_str[70]={[0]='\0'};
dap_chain_hash_fast_to_str(&l_out->subtype.srv_pay.pkey_hash, l_pkey_hash_str, sizeof (l_pkey_hash_str)-1);
dap_string_append_printf(a_str_out,"\tpkey_hash: %s\n", l_pkey_hash_str );
@@ -2986,6 +3011,14 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
}
}
+/**
+ * @brief check certificate access list, written in chain config
+ *
+ * @param a_net - network object
+ * @param a_pkey_hash - certificate hash
+ * @return true
+ * @return false
+ */
static bool s_net_check_acl(dap_chain_net_t *a_net, dap_chain_hash_fast_t *a_pkey_hash)
{
const char l_path[] = "network/";
@@ -3046,6 +3079,12 @@ static bool s_net_check_acl(dap_chain_net_t *a_net, dap_chain_hash_fast_t *a_pke
return l_authorized;
}
+/**
+ * @brief s_acl_callback function. Usually called from enc_http_proc
+ * set acl (l_enc_key_ks->acl_list) from acl_accept_ca_list, acl_accept_ca_gdb chain config parameters in [auth] section
+ * @param a_pkey_hash dap_chain_hash_fast_t hash object
+ * @return uint8_t*
+ */
static uint8_t *dap_chain_net_set_acl(dap_chain_hash_fast_t *a_pkey_hash)
{
uint16_t l_net_count;
diff --git a/modules/net/dap_chain_node.c b/modules/net/dap_chain_node.c
index bf92f61f6bd6b2d22c27bf859fa61800f06bb324..89717fd4ef0ba0625676ba415370353baca2a0ef 100644
--- a/modules/net/dap_chain_node.c
+++ b/modules/net/dap_chain_node.c
@@ -49,7 +49,7 @@
#define LOG_TAG "chain_node"
/**
- * Generate node address by shard id
+ * Generate node address
*/
dap_chain_node_addr_t* dap_chain_node_gen_addr(dap_chain_net_id_t a_net_id)
{
@@ -224,7 +224,7 @@ dap_chain_node_info_t* dap_chain_node_info_read( dap_chain_net_t * a_net,dap_cha
return node_info;
}*/
-int dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_node_role_t a_role, dap_chain_datum_t *a_datum)
+int dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_datum)
{
bool l_need_process = false;
for (uint16_t j = 0; j < a_chain->autoproc_datum_types_count; j++) {
@@ -235,31 +235,21 @@ int dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_node_role_t a
}
if (!l_need_process)
return -1;
- if (a_datum->header.type_id == DAP_CHAIN_DATUM_TX) {
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t *)a_datum->data;
- dap_chain_tx_in_t *l_tx_in = (dap_chain_tx_in_t *)dap_chain_datum_tx_item_get(l_tx, NULL, TX_ITEM_TYPE_IN, NULL);
- // Is not it a base transaction?
- if (l_tx_in && !dap_hash_fast_is_blank(&l_tx_in->header.tx_prev_hash)) {
- if (a_role.enums == NODE_ROLE_ROOT) {
- return -1;
- }
- }
- }
+ // Auth signs for emissions already verified by this callback
return (int)a_chain->callback_add_datums(a_chain, &a_datum, 1);
}
-static bool s_mempool_auto = false;
/**
- * @brief
+ * @brief
* get automatic mempool processing, when network config contains mempool_auto_types for specific datums
- * @return true
- * @return false
+ * @return true
+ * @return false
*/
bool dap_chain_node_mempool_autoproc_init()
{
uint16_t l_net_count;
- bool l_mempool_auto_default = false;
+ bool l_mempool_auto_default = false, l_ret = false;
dap_chain_net_t **l_net_list = dap_chain_net_list(&l_net_count);
for (uint16_t i = 0; i < l_net_count; i++) {
dap_chain_node_role_t l_role = dap_chain_net_get_role(l_net_list[i]);
@@ -272,10 +262,12 @@ bool dap_chain_node_mempool_autoproc_init()
l_mempool_auto_default = true;
break;
default:
+ l_mempool_auto_default = false;
break;
}
- s_mempool_auto = dap_config_get_item_bool_default(g_config, "mempool", "auto_proc", l_mempool_auto_default);
- if (s_mempool_auto) {
+ l_net_list[i]->pub.mempool_autoproc = dap_config_get_item_bool_default(g_config, "mempool", "auto_proc", l_mempool_auto_default);
+ if (l_net_list[i]->pub.mempool_autoproc) {
+ l_ret = true;
dap_chain_t *l_chain;
DL_FOREACH(l_net_list[i]->pub.chains, l_chain) {
if (!l_chain) {
@@ -290,7 +282,7 @@ bool dap_chain_node_mempool_autoproc_init()
if (!l_objs[i].value_len)
continue;
dap_chain_datum_t *l_datum = (dap_chain_datum_t *)l_objs[i].value;
- if (dap_chain_node_mempool_process(l_chain, l_role, l_datum) > 0) {
+ if (dap_chain_node_mempool_process(l_chain, l_datum) >= 0) {
// Delete processed objects
dap_chain_global_db_gr_del(dap_strdup(l_objs[i].key), l_gdb_group_mempool);
}
@@ -302,7 +294,7 @@ bool dap_chain_node_mempool_autoproc_init()
}
}
DAP_DELETE(l_net_list);
- return s_mempool_auto;
+ return l_ret;
}
/**
@@ -310,17 +302,18 @@ bool dap_chain_node_mempool_autoproc_init()
*/
void dap_chain_node_mempool_autoproc_deinit()
{
- s_mempool_auto = false;
}
void dap_chain_node_mempool_autoproc_notify(void *a_arg, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_len)
{
UNUSED(a_value_len);
- if (!a_arg || !a_value || !s_mempool_auto || a_op_code != 'a') {
+ if (!a_arg || !a_value || a_op_code != 'a') {
return;
}
dap_chain_net_t *l_net = (dap_chain_net_t *)a_arg;
+ if (!l_net->pub.mempool_autoproc)
+ return;
dap_chain_t *l_chain;
DL_FOREACH(l_net->pub.chains, l_chain) {
if (!l_chain) {
@@ -329,8 +322,7 @@ void dap_chain_node_mempool_autoproc_notify(void *a_arg, const char a_op_code, c
char *l_gdb_group_str = dap_chain_net_get_gdb_group_mempool(l_chain);
if (!strcmp(a_group, l_gdb_group_str)) {
dap_chain_datum_t *l_datum = (dap_chain_datum_t *)a_value;
- dap_chain_node_role_t l_role = dap_chain_net_get_role(l_net);
- if (dap_chain_node_mempool_process(l_chain, l_role, l_datum) > 0) {
+ if (dap_chain_node_mempool_process(l_chain, l_datum) >= 0) {
dap_chain_global_db_gr_del(dap_strdup(a_key), l_gdb_group_str);
}
}
diff --git a/modules/net/dap_chain_node_cli.c b/modules/net/dap_chain_node_cli.c
index c3ed8698873fde589373462351ff00ef44043f4f..9f350b946833b87bef110b1d23e452875620d7f2 100644
--- a/modules/net/dap_chain_node_cli.c
+++ b/modules/net/dap_chain_node_cli.c
@@ -1088,8 +1088,8 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
dap_chain_node_cli_cmd_item_create ("tx_cond_create", com_tx_cond_create, "Make cond transaction",
"tx_cond_create -net <net name> -token <token_ticker> -wallet_f <wallet_from> -wallet_t <wallet_to>"
"-value <value_datoshi> -unit <mb|kb|b|sec|day> -service <vpn>\n" );
- dap_chain_node_cli_cmd_item_create ("tx_verify", com_tx_verify, "Verifing transaction",
- "tx_verify -wallet <wallet name> \n" );
+ dap_chain_node_cli_cmd_item_create ("tx_verify", com_tx_verify, "Verifing transaction in mempool",
+ "tx_verify -net <net name> -chain <chain name> -tx <tx_hash>\n" );
// Transaction history
dap_chain_node_cli_cmd_item_create("tx_history", com_tx_history, "Transaction history (for address or by hash)",
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 55b797a4dcfc9b1111faf886d161c957e435affe..4340f7d671d56486565efc741cf41c0a2567a76a 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -1803,10 +1803,9 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
for(size_t i = 0; i < l_addr_tokens_size; i++) {
if(l_addr_tokens[i]) {
- // uint128_t l_balance = dap_chain_ledger_calc_balance(l_ledger, l_addr, l_addr_tokens[i]);
uint256_t l_balance = dap_chain_ledger_calc_balance(l_ledger, l_addr, l_addr_tokens[i]);
- char *l_balance_coins = dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_balance));
- char *l_balance_datoshi = dap_chain_balance_print(dap_chain_uint128_from_uint256(l_balance));
+ char *l_balance_coins = dap_chain_balance_to_coins(l_balance);
+ char *l_balance_datoshi = dap_chain_balance_print(l_balance);
dap_string_append_printf(l_string_ret, "\t%s (%s) %s\n", l_balance_coins,
l_balance_datoshi, l_addr_tokens[i]);
if(i < l_addr_tokens_size - 1)
@@ -2460,7 +2459,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
int l_arg_index = 1;
const char * l_type_str = NULL;
- uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
+ uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE;
const char * l_ticker = NULL;
@@ -2494,9 +2493,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
// Token type
l_arg_index=dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-type", &l_type_str);
- if (!l_type_str || !strcmp(l_type_str, "private")) {
- l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE; // 256
- } else {
+ if (l_type_str && strcmp(l_type_str, "private")) {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_update can't accept type \"%s\"", l_type_str);
return -22;
}
@@ -2505,7 +2502,6 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
size_t l_datum_data_offset = 0;
switch(l_type){
- case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:{ // 256
dap_list_t *l_tsd_list = dap_list_alloc();
size_t l_tsd_total_size = 0;
@@ -2559,15 +2555,9 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
}
} else if ( strcmp( a_argv[l_arg_index],"-total_supply" )==0){ // Total supply
dap_tsd_t * l_tsd;
- if ( dap_chain_datum_token_is_old(l_type) ) { // 128
- uint128_t l_param_value = dap_chain_balance_scan(l_arg_param);
- l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY, l_param_value);
- } else { // 256
- uint256_t l_param_value = GET_256_FROM_128(dap_chain_balance_scan(l_arg_param));
- l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256, l_param_value);
- }
+ uint256_t l_param_value = dap_chain_balance_scan(l_arg_param);
+ l_tsd = dap_tsd_create_scalar(
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256, l_param_value);
dap_list_append( l_tsd_list, l_tsd);
l_tsd_total_size+= dap_tsd_size( l_tsd);
}else if ( strcmp( a_argv[l_arg_index],"-total_signs_valid" )==0){ // Signs valid
@@ -2788,7 +2778,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
const char * l_ticker = NULL;
const char * l_total_supply_str = NULL;
- uint256_t l_total_supply = uint256_0; // 256
+ uint256_t l_total_supply = {}; // 256
const char * l_signs_emission_str = NULL;
uint16_t l_signs_emission = 0;
@@ -2804,12 +2794,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_t * l_chain = NULL;
dap_chain_net_t * l_net = NULL;
- // 256
- bool l_type_256 = true; //dap_chain_node_cli_check_option(a_argv, l_arg_index, a_argc, "-256") == -1 ? false : true;
-
- uint16_t l_type = l_type_256
- ? DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE // 256
- : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE;
+ uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
const char * l_hash_out_type = NULL;
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
@@ -2842,14 +2827,11 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
if (l_type_str) {
if (strcmp( l_type_str, "private") == 0){
- l_type = l_type_256 ? DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL // 256
- : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL;
+ l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL; // 256
}else if (strcmp( l_type_str, "private_simple") == 0){
- l_type = l_type_256 ? DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE // 256
- : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE;
+ l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
}else if (strcmp( l_type_str, "public_simple") == 0){
- l_type = l_type_256 ? DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC // 256
- : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC;
+ l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC; // 256
}
}
@@ -2857,8 +2839,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
size_t l_datum_data_offset = 0;
switch(l_type){
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
- case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL: {
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: { // 256
dap_list_t *l_tsd_list = dap_list_alloc();
size_t l_tsd_total_size = 0;
uint16_t l_flags = 0;
@@ -2879,15 +2860,9 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
}
} else if ( strcmp( a_argv[l_arg_index],"-total_supply" )==0){ // Total supply
dap_tsd_t * l_tsd;
- if ( l_type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL ) { // 256
- uint256_t l_param_value = GET_256_FROM_128(dap_chain_balance_scan(l_arg_param));
- l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256, l_param_value);
- } else { // 128
- uint128_t l_param_value = dap_chain_balance_scan(l_arg_param);
- l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY, l_param_value);
- }
+ uint256_t l_param_value = dap_chain_balance_scan(l_arg_param);
+ l_tsd = dap_tsd_create_scalar(
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256, l_param_value);
dap_list_append( l_tsd_list, l_tsd);
l_tsd_total_size+= dap_tsd_size( l_tsd);
}else if ( strcmp( a_argv[l_arg_index],"-total_signs_valid" )==0){ // Signs valid
@@ -2981,14 +2956,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
switch (l_tsd->type){
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: { // 256
char *l_balance;
- l_balance = dap_chain_u256tostr(dap_tsd_get_scalar(l_tsd, uint256_t));
- log_it(L_DEBUG,"== TOTAL_SUPPLY: %s", l_balance);
- DAP_DELETE(l_balance);
- }
- break;
- case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: { // 128
- char *l_balance;
- l_balance = dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint128_t));
+ l_balance = dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint256_t));
log_it(L_DEBUG,"== TOTAL_SUPPLY: %s", l_balance);
DAP_DELETE(l_balance);
}
@@ -3027,8 +2995,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
}break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
- case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: { // 256
// Total supply value
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-total_supply", &l_total_supply_str);
@@ -3042,14 +3009,11 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// Signs minimum number thats need to authorize the emission
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-signs_emission", &l_signs_emission_str);
-
if(!l_total_supply_str) {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-total_supply'");
return -3;
} else {
- // char * l_tmp = NULL;
- l_total_supply = GET_256_FROM_128(dap_chain_balance_scan(l_total_supply_str));
- //if((l_total_supply = strtoull(l_total_supply_str, &l_tmp, 10)) == 0) {
+ l_total_supply = dap_chain_balance_scan((char *)l_total_supply_str);
if ( IS_ZERO_256(l_total_supply) ) {
dap_chain_node_cli_set_reply_text(a_str_reply,
"token_create requires parameter '-total_supply' to be unsigned integer value that fits in 8 bytes");
@@ -3057,8 +3021,6 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
}
}
-
-
// Signs emission
if(!l_signs_emission_str) {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-signs_emission'");
@@ -3105,14 +3067,9 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// Create new datum token
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t));
- l_datum_token->type = l_type_256
- ? DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE // 256
- : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE;
+ l_datum_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
dap_snprintf(l_datum_token->ticker, sizeof(l_datum_token->ticker), "%s", l_ticker);
- if ( l_type_256 )
- l_datum_token->header_private.total_supply_256 = l_total_supply;
- else
- l_datum_token->header_private.total_supply = dap_chain_uint256_to(l_total_supply);
+ l_datum_token->header_private.total_supply_256 = l_total_supply;
l_datum_token->header_private.signs_total = l_signs_total;
l_datum_token->header_private.signs_valid = l_signs_emission;
@@ -3136,13 +3093,9 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
return -8;
}
- dap_chain_datum_t * l_datum = l_type_256
- ? dap_chain_datum_create( // 256
- DAP_CHAIN_DATUM_256_TOKEN_DECL,
- l_datum_token, sizeof(*l_datum_token) + l_datum_data_offset)
- : dap_chain_datum_create(
- DAP_CHAIN_DATUM_TOKEN_DECL,
- l_datum_token, sizeof(*l_datum_token) + l_datum_data_offset);
+ dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_DECL,
+ l_datum_token,
+ sizeof(*l_datum_token) + l_datum_data_offset);
size_t l_datum_size = dap_chain_datum_size(l_datum);
// Calc datum's hash
@@ -3153,7 +3106,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// Add datum to mempool with datum_token hash as a key
char * l_gdb_group_mempool;
- if(l_chain) {
+ if (l_chain) {
l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
}
else {
@@ -3161,15 +3114,11 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
}
int l_ret = 0;
- char * l_datum_type = l_type_256 ? "256_t" : "";
- if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool)) {
- if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s %s with token %s is placed in datum pool ", l_datum_type, l_key_str, l_ticker);
- else
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s %s with token %s is placed in datum pool ", l_datum_type, l_key_str_base58, l_ticker);
- }
- else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum tx %s %s is not placed in datum pool ", l_datum_type, l_key_str_base58);
+ bool l_placed = dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s with 256bit token %s is%s placed in datum pool",
+ dap_strcmp(l_hash_out_type, "hex") ? l_key_str_base58 : l_key_str,
+ l_ticker, l_placed ? "" : " not");
+ if (!l_placed) {
DAP_DELETE(l_datum);
l_ret = -2;
}
@@ -3189,23 +3138,15 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
int arg_index = 1;
const char *str_tmp = NULL;
char *str_reply_tmp = NULL;
- // uint64_t l_emission_value = 0;
- uint256_t l_emission_value = uint256_0;
-
+ uint256_t l_emission_value = {};
const char * l_ticker = NULL;
const char * l_addr_str = NULL;
const char * l_emission_hash_str = NULL;
- bool l_type_256 = true; // false;
-
- char * l_emission_hash_str_new = NULL;
dap_chain_hash_fast_t l_emission_hash={0};
-
dap_chain_datum_token_emission_t * l_emission = NULL;
- //dap_chain_datum_256_token_emission_t * l_emission_256 = NULL; // 256
-
char * l_emission_hash_str_base58 = NULL;
const char * l_certs_str = NULL;
@@ -3225,7 +3166,6 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
-
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
@@ -3241,10 +3181,6 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
// Token emission
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission", &l_emission_hash_str);
- // 256
- // dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-256", &l_type_256);
- //l_type_256 = dap_chain_node_cli_check_option(a_argv, arg_index, a_argc, "-256") == -1 ? false : true;
-
// Emission certs
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
@@ -3256,15 +3192,15 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
// Emission value
if(dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission_value", &str_tmp)) {
- // l_emission_value = strtoull(str_tmp, NULL, 10);
- l_emission_value = GET_256_FROM_128(dap_chain_balance_scan(str_tmp));
+ l_emission_value = dap_chain_balance_scan(str_tmp);
}
- if( EQUAL_256(l_emission_value, uint256_0) ) {
+ if (IS_ZERO_256(l_emission_value)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-emission_value'");
return -1;
}
+
if(!l_addr_str) {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-addr'");
return -2;
@@ -3280,6 +3216,7 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
return -4;
}
+
if (l_emission_hash_str){// Load emission
l_emission_hash_str_base58 = dap_enc_base58_encode_hash_to_str(&l_emission_hash);
if (dap_chain_hash_fast_from_str( l_emission_hash_str,&l_emission_hash) == 0 ){
@@ -3312,6 +3249,8 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
}
}
+
+
dap_chain_addr_t * l_addr = dap_chain_addr_from_str(l_addr_str);
if(!l_addr) {
@@ -3339,12 +3278,9 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
else {
l_gdb_group_mempool_base_tx = dap_chain_net_get_gdb_group_mempool_by_chain_type(l_net, CHAIN_TYPE_TX);
}
- //char * l_gdb_group_mempool_emission = dap_chain_net_get_gdb_group_mempool(l_chain_emission);
- //char * l_gdb_group_mempool_base_tx = dap_chain_net_get_gdb_group_mempool(l_chain_base_tx);
-
// Create emission datum
// then create datum in memory
- if(!l_emission){
+ if (!l_emission) {
char * l_gdb_group_mempool_emission;
if(l_chain_emission) {
l_gdb_group_mempool_emission = dap_chain_net_get_gdb_group_mempool(l_chain_emission);
@@ -3355,35 +3291,19 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
size_t l_emission_size = sizeof(l_emission->hdr) +
sizeof(l_emission->data.type_auth.signs_count);
- // size_t l_emission_256_size = sizeof(l_emission_256->hdr) +
- // sizeof(l_emission_256->data.type_auth.signs_count);
-
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_emission_size);
-
- if ( !l_type_256 ) {
- // l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
- // l_emission->hdr.type_256 = false;
- l_emission->hdr.value = dap_chain_uint256_to(l_emission_value);
- } else { // 256
- // l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH;
- // l_emission->hdr.type_256 = true;
- l_emission->hdr.value_256 = l_emission_value;
- }
-
- l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
- l_emission->hdr.version = 1;
-
+ l_emission->hdr.version = 2;
+ l_emission->hdr.value_256 = l_emission_value;
strncpy(l_emission->hdr.ticker, l_ticker, sizeof(l_emission->hdr.ticker) - 1);
- // l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
+ l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
memcpy(&l_emission->hdr.address, l_addr, sizeof(l_emission->hdr.address));
-
time_t l_time = time(NULL);
memcpy(&l_emission->hdr.nonce, &l_time, sizeof(time_t));
+ l_emission->data.type_auth.signs_count = l_certs_size;
// Then add signs
size_t l_offset = 0;
-
for(size_t i = 0; i < l_certs_size; i++) {
- dap_sign_t * l_sign = dap_cert_sign(l_certs[i], &l_emission->hdr,
+ dap_sign_t *l_sign = dap_cert_sign(l_certs[i], &l_emission->hdr,
sizeof(l_emission->hdr), 0);
size_t l_sign_size = dap_sign_get_size(l_sign);
l_emission_size += l_sign_size;
@@ -3393,95 +3313,51 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
DAP_DELETE(l_sign);
}
- dap_chain_datum_t * l_datum_emission;
-
// Produce datum
- if ( !l_type_256 )
- l_datum_emission = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_EMISSION,
- l_emission,
- l_emission_size);
- else // 256
- l_datum_emission = dap_chain_datum_create(DAP_CHAIN_DATUM_256_TOKEN_EMISSION,
- l_emission,
- l_emission_size);
-
+ dap_chain_datum_t *l_datum_emission = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_EMISSION,
+ l_emission,
+ l_emission_size);
size_t l_datum_emission_size = sizeof(l_datum_emission->header) + l_datum_emission->header.data_size;
- // Calc token's hash
- //dap_chain_hash_fast_t l_emission_hash;
- dap_hash_fast(l_emission, l_emission_size, &l_emission_hash);
-
- l_emission_hash_str = l_emission_hash_str_new = dap_chain_hash_fast_to_str_new(&l_emission_hash);
+ // Calc datum emission's hash
+ dap_hash_fast(l_datum_emission, l_datum_emission_size, &l_emission_hash);
+ l_emission_hash_str = dap_chain_hash_fast_to_str_new(&l_emission_hash);
l_emission_hash_str_base58 = dap_enc_base58_encode_hash_to_str(&l_emission_hash);
// Delete token emission
DAP_DEL_Z(l_emission);
- //DAP_DEL_Z(l_emission_256); // 256
-
-// // Calc datum's hash
-// dap_chain_hash_fast_t l_datum_emission_hash;
-// dap_hash_fast(l_datum_emission, l_datum_emission_size, (uint8_t*) &l_datum_emission_hash);
-// char * l_key_str = dap_chain_hash_fast_to_str_new(&l_datum_emission_hash);
-
- // Add to mempool emission token
- if(dap_chain_global_db_gr_set(dap_strdup(l_emission_hash_str_new), (uint8_t *) l_datum_emission, l_datum_emission_size
- , l_gdb_group_mempool_emission)) {
- if(!dap_strcmp(l_hash_out_type,"hex"))
- str_reply_tmp = dap_strdup_printf("Datum%s emission %s is placed in datum pool",
- (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
- l_emission_hash_str_new);
- else
- str_reply_tmp = dap_strdup_printf("Datum%s emission %s is placed in datum pool",
- (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
- l_emission_hash_str_base58);
- }
- else {
- if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum%s emission %s is not placed in datum pool",
- (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
- l_emission_hash_str_new);
- else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum%s emission %s is not placed in datum pool",
- (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
- l_emission_hash_str_base58);
- DAP_DEL_Z(l_emission_hash_str_new);
- l_emission_hash_str = NULL;
- DAP_DEL_Z(l_emission_hash_str_base58);
+
+ // Add token emission datum to mempool
+ bool l_placed = dap_chain_global_db_gr_set(dap_strdup(l_emission_hash_str),
+ (uint8_t *)l_datum_emission,
+ l_datum_emission_size,
+ l_gdb_group_mempool_emission);
+ str_reply_tmp = dap_strdup_printf("Datum %s with 256bit emission is%s placed in datum pool",
+ dap_strcmp(l_hash_out_type, "hex") ? l_emission_hash_str_base58 : l_emission_hash_str,
+ l_placed ? "" : " not");
+ DAP_DELETE((char *)l_emission_hash_str);
+ DAP_DEL_Z(l_emission_hash_str_base58);
+ if (!l_placed) {
DAP_DEL_Z(l_datum_emission);
return -1;
}
l_datum_emission = NULL;
- l_emission = NULL;
- }
+ } // TODO possible update emission if it found, or remove -emission parameter
// create first transaction (with tx_token)
dap_chain_datum_tx_t *l_tx = DAP_NEW_Z_SIZE(dap_chain_datum_tx_t, sizeof(dap_chain_datum_tx_t));
+ l_tx->header.ts_created = time(NULL);
dap_chain_hash_fast_t l_tx_prev_hash = { 0 };
- dap_chain_tx_token_t *l_tx_token;
- dap_chain_tx_out_t *l_out;
- //dap_chain_256_tx_out_t *l_out_256;
-
// create items
- if ( !l_type_256 ) {
- l_tx_token = dap_chain_datum_tx_item_token_create(&l_emission_hash, l_ticker);
- l_out = dap_chain_datum_tx_item_out_create(l_addr, dap_chain_uint256_to(l_emission_value));
- } else { // 256
- l_tx_token = dap_chain_datum_tx_item_256_token_create(&l_emission_hash, l_ticker);
- l_out = dap_chain_datum_tx_item_256_out_create(l_addr, l_emission_value);
- }
+ dap_chain_tx_token_t *l_tx_token = dap_chain_datum_tx_item_token_create(&l_emission_hash, l_ticker);
dap_chain_tx_in_t *l_in = dap_chain_datum_tx_item_in_create(&l_tx_prev_hash, 0);
+ dap_chain_256_tx_out_t *l_out = dap_chain_datum_tx_item_out_create(l_addr, l_emission_value);
// pack items to transaction
dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*) l_tx_token);
dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*) l_in);
-
- //if ( !l_type_256 ) {
dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*) l_out);
- // } else { //256
- // dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*) l_out_256);
- // }
- // Base tx don't need signature items but let it be
if (l_certs){
// Sign all that we have with certs
for(size_t i = 0; i < l_certs_size; i++) {
@@ -3499,26 +3375,14 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
DAP_DEL_Z(l_tx_token);
DAP_DEL_Z(l_in);
- // DAP_DEL_Z(l_out);
- // DAP_DEL_Z(l_out_256);
-
- DAP_DEL_Z(l_emission_hash_str_new);
- l_emission_hash_str = NULL;
- DAP_DEL_Z(l_emission_hash_str_base58);
+ DAP_DEL_Z(l_out);
size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
- dap_chain_datum_t * l_datum_tx;
// Pack transaction into the datum
- if ( !l_type_256 ) {
- l_datum_tx = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size);
- } else {
- l_datum_tx = dap_chain_datum_create(DAP_CHAIN_DATUM_256_TX, l_tx, l_tx_size);
- }
+ dap_chain_datum_t * l_datum_tx = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size);
size_t l_datum_tx_size = dap_chain_datum_size(l_datum_tx);
- // use l_tx hash for compatible with utho hash
- //dap_hash_fast(l_tx, l_tx_size, &l_key_hash); //dap_hash_fast(l_datum_tx, l_datum_tx_size, &l_key_hash);
// calc datum hash
dap_chain_hash_fast_t l_datum_tx_hash;
dap_hash_fast(l_datum_tx, l_datum_tx_size, &l_datum_tx_hash);
@@ -3527,38 +3391,21 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
DAP_DEL_Z(l_tx);
// Add to mempool tx token
- if(dap_chain_global_db_gr_set(dap_strdup(l_tx_hash_str), l_datum_tx, l_datum_tx_size
- , l_gdb_group_mempool_base_tx)) {
- if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is placed in datum pool ",
- str_reply_tmp,
- (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
- l_tx_hash_str);
- else
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is placed in datum pool ",
- str_reply_tmp,
- (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
- l_tx_hash_str_base58);
- DAP_DEL_Z(l_tx_hash_str);
- DAP_DEL_Z(l_tx_hash_str_base58);
- } else {
- if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is not placed in datum pool ",
- str_reply_tmp,
- (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
- l_emission_hash_str);
- else
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is not placed in datum pool ",
- str_reply_tmp,
- (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
- l_tx_hash_str_base58);
- DAP_DEL_Z(l_tx_hash_str);
- DAP_DEL_Z(l_tx_hash_str_base58);
-
- return -2;
- }
+ bool l_placed = dap_chain_global_db_gr_set(dap_strdup(l_tx_hash_str), l_datum_tx,
+ l_datum_tx_size, l_gdb_group_mempool_base_tx);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "%s\nDatum %s with 256bit TX is%s placed in datum pool ",
+ str_reply_tmp,
+ dap_strcmp(l_hash_out_type, "hex") ? l_tx_hash_str_base58 : l_tx_hash_str,
+ l_placed ? "" : " not");
+ DAP_DEL_Z(l_tx_hash_str);
+ DAP_DEL_Z(l_tx_hash_str_base58);
DAP_DELETE(str_reply_tmp);
DAP_DELETE(l_addr);
+ if (!l_placed) {
+ DAP_DELETE(l_datum_tx);
+ return -2;
+ }
+
return 0;
}
@@ -3584,8 +3431,7 @@ int com_tx_cond_create(int a_argc, char ** a_argv, char **a_str_reply)
const char * l_net_name = NULL;
const char * l_unit_str = NULL;
const char * l_service_str = NULL;
- uint64_t l_value_datoshi = 0;
-
+ uint256_t l_value_datoshi = {};
const char * l_hash_out_type = NULL;
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
@@ -3667,8 +3513,8 @@ int com_tx_cond_create(int a_argc, char ** a_argv, char **a_str_reply)
return -9;
}
- l_value_datoshi = strtoll(l_value_datoshi_str, NULL, 10);
- if(!l_value_datoshi) {
+ l_value_datoshi = dap_chain_balance_scan(l_value_datoshi_str);
+ if(IS_ZERO_256(l_value_datoshi)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "can't recognize value='%s' as a number", l_value_datoshi_str);
return -10;
}
@@ -3708,9 +3554,10 @@ int com_tx_cond_create(int a_argc, char ** a_argv, char **a_str_reply)
addr_cond,
NULL, l_token_ticker, l_value, 0, (const void*) &l_cond, sizeof(dap_chain_net_srv_abstract_t));
*/
-
+ uint256_t l_value_per_unit_max = {};
+ uint256_t l_value_fee = {};
dap_chain_hash_fast_t *l_tx_cond_hash = dap_chain_mempool_tx_create_cond(l_net, l_key_from, l_key_cond, l_addr_from, l_token_ticker,
- l_value_datoshi, 0, l_price_unit, l_srv_uid, 0, NULL, 0);
+ l_value_datoshi, l_value_per_unit_max, l_price_unit, l_srv_uid, l_value_fee, NULL, 0);
dap_chain_wallet_close(l_wallet_from);
dap_chain_wallet_close(l_wallet_cond);
@@ -3958,12 +3805,8 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
const char * l_tx_num_str = NULL;
size_t l_tx_num = 0;
- uint64_t value = 0;
- uint64_t value_fee = 0;
-
- // uint256_t value = uint256_0;
- // uint256_t value_fee = uint256_0;
-
+ uint256_t l_value = {};
+ uint256_t l_value_fee = {};
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-from_wallet", &l_from_wallet_name);
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-to_addr", &addr_base58_to);
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-token", &l_token_ticker);
@@ -3976,11 +3819,11 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
if(dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-fee", &addr_base58_fee)) {
if(dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-value_fee", &str_tmp)) {
- value_fee = strtoull(str_tmp, NULL, 10);
+ l_value_fee = dap_chain_balance_scan(str_tmp);
}
}
if(dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-value", &str_tmp)) {
- value = strtoull(str_tmp, NULL, 10);
+ l_value = dap_chain_balance_scan(str_tmp);
}
if(!l_from_wallet_name) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-from_wallet'");
@@ -3990,11 +3833,11 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-to_addr'");
return -1;
}
- if(!value) {
+ if(IS_ZERO_256(l_value)) {
dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-value'");
return -1;
}
- if(addr_base58_fee && !value_fee) {
+ if(addr_base58_fee && IS_ZERO_256(l_value_fee)) {
dap_chain_node_cli_set_reply_text(str_reply,
"tx_create requires parameter '-value_fee' if '-fee' is specified");
return -1;
@@ -4056,14 +3899,14 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
if(l_tx_num){
res = dap_chain_mempool_tx_create_massive(l_chain, dap_chain_wallet_get_key(l_wallet, 0), addr_from,
addr_to, addr_fee,
- l_token_ticker, value, value_fee, l_tx_num);
+ l_token_ticker, l_value, l_value_fee, l_tx_num);
dap_string_append_printf(string_ret, "transfer=%s\n",
(res == 0) ? "Ok" : (res == -2) ? "False, not enough funds for transfer" : "False");
}else{
dap_hash_fast_t * l_tx_hash = dap_chain_mempool_tx_create(l_chain, dap_chain_wallet_get_key(l_wallet, 0), addr_from, addr_to,
addr_fee,
- l_token_ticker, value, value_fee);
+ l_token_ticker, l_value, l_value_fee);
if (l_tx_hash){
char l_tx_hash_str[80]={[0]='\0'};
dap_chain_hash_fast_to_str(l_tx_hash,l_tx_hash_str,sizeof (l_tx_hash_str)-1);
@@ -4096,15 +3939,48 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
* @param str_reply
* @return int
*/
-int com_tx_verify(int argc, char ** argv, char **str_reply)
+int com_tx_verify(int a_argc, char **a_argv, char **a_str_reply)
{
- if(argc > 1) {
- if(str_reply)
- dap_chain_node_cli_set_reply_text(str_reply, "command \"%s\" not recognized", argv[1]);
+ const char * l_tx_hash_str = NULL;
+ dap_chain_net_t * l_net = NULL;
+ dap_chain_t * l_chain = NULL;
+ int l_arg_index = 1;
+
+ dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
+ if(!l_tx_hash_str) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "tx_verify requires parameter '-tx'");
+ return -1;
}
- else if(str_reply)
- dap_chain_node_cli_set_reply_text(str_reply, "command not defined, enter \"help <cmd name>\"");
- return -1;
+ dap_chain_node_cli_cmd_values_parse_net_chain(&l_arg_index, a_argc, a_argv, a_str_reply, &l_chain, &l_net);
+ if (!l_net || !l_chain) {
+ return -2;
+ } else if (a_str_reply && *a_str_reply) {
+ DAP_DELETE(*a_str_reply);
+ *a_str_reply = NULL;
+ }
+ dap_hash_fast_t l_tx_hash;
+ char *l_hex_str_from58 = NULL;
+ if (dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash) < 0) {
+ l_hex_str_from58 = dap_enc_base58_to_hex_str_from_str(l_tx_hash_str);
+ if (!l_hex_str_from58) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid tx hash format, need hex or base58");
+ return -3;
+ }
+ }
+ size_t l_tx_size = 0;
+ char *l_gdb_group = dap_chain_net_get_gdb_group_mempool(l_chain);
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t *)
+ dap_chain_global_db_gr_get(l_hex_str_from58 ? l_hex_str_from58 : l_tx_hash_str, &l_tx_size, l_gdb_group);
+ if (!l_tx) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Specified tx not found");
+ return -3;
+ }
+ if (dap_chain_ledger_tx_add_check(l_net->pub.ledger, l_tx)) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Specified tx verify fail!");
+ return -4;
+ }
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Specified tx verified successfully");
+ return 0;
}
@@ -4134,7 +4010,7 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -4214,12 +4090,12 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
char *l_str_ret = NULL;
if(l_tx_hash_str) {
- l_str_ret = dap_strdup_printf("history for tx hash %s:\n%s", l_tx_hash_str,
+ l_str_ret = dap_strdup_printf("History for tx hash %s:\n%s", l_tx_hash_str,
l_str_out ? l_str_out : " empty");
}
else if(l_addr) {
char *l_addr_str = dap_chain_addr_to_str(l_addr);
- l_str_ret = dap_strdup_printf("history for addr %s:\n%s", l_addr_str,
+ l_str_ret = dap_strdup_printf("History for addr %s:\n%s", l_addr_str,
l_str_out ? l_str_out : " empty");
DAP_DELETE(l_addr_str);
}
@@ -4369,54 +4245,35 @@ int cmd_gdb_export(int argc, char ** argv, char ** a_str_reply)
return -1;
}
const char *l_db_path = dap_config_get_item_str(g_config, "resources", "dap_global_db_path");
-
- // NB! [TEMPFIX] Temporarily backward-compatible until migration to new databases locations (after updates)
- const char *l_db_driver = dap_config_get_item_str(g_config, "resources", "dap_global_db_driver");
- char l_db_concat[80];
- dap_sprintf(l_db_concat, "%s/gdb-%s", l_db_path, l_db_driver);
-
- struct dirent *d;
- DIR *dir = opendir(l_db_concat);
+ DIR *dir = opendir(l_db_path);
if (!dir) {
- // External "if" to check out old or new path.
- log_it(L_WARNING, "Probably db directory is in old path. Checking out.");
- dir = opendir(l_db_path);
- if (!dir) {
- log_it(L_ERROR, "Can't open db directory");
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't open db directory");
- return -1;
- }
+ log_it(L_ERROR, "Can't open db directory");
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Can't open db directory");
+ return -1;
}
char l_path[strlen(l_db_path) + strlen(l_filename) + 12];
memset(l_path, '\0', sizeof(l_path));
dap_snprintf(l_path, sizeof(l_path), "%s/%s.json", l_db_path, l_filename);
- /*FILE *l_json_file = fopen(l_path, "a");
- if (!l_json_file) {
- log_it(L_ERROR, "Can't open file %s", l_path);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't open specified file");
- return -1;
- }*/
+
struct json_object *l_json = json_object_new_array();
- for (d = readdir(dir); d; d = readdir(dir)) {
- if (!dap_strcmp(d->d_name, ".") || !dap_strcmp(d->d_name, "..")) {
- continue;
- }
+ dap_list_t *l_groups_list = dap_chain_global_db_driver_get_groups_by_mask("*");
+ for (dap_list_t *l_list = l_groups_list; l_list; l_list = dap_list_next(l_list)) {
size_t l_data_size = 0;
- pdap_store_obj_t l_data = dap_chain_global_db_obj_gr_get(NULL, &l_data_size, d->d_name);
- log_it(L_INFO, "Exporting group %s, number of records: %zu", d->d_name, l_data_size);
+ char *l_group_name = (char *)l_list->data;
+ pdap_store_obj_t l_data = dap_chain_global_db_obj_gr_get(NULL, &l_data_size, l_group_name);
+ log_it(L_INFO, "Exporting group %s, number of records: %zu", l_group_name, l_data_size);
if (!l_data_size) {
continue;
}
struct json_object *l_json_group = json_object_new_array();
struct json_object *l_json_group_inner = json_object_new_object();
- json_object_object_add(l_json_group_inner, "group", json_object_new_string(d->d_name));
+ json_object_object_add(l_json_group_inner, "group", json_object_new_string(l_group_name));
for (size_t i = 0; i < l_data_size; ++i) {
size_t l_out_size = DAP_ENC_BASE64_ENCODE_SIZE((int64_t)l_data[i].value_len) + 1;
char *l_value_enc_str = DAP_NEW_Z_SIZE(char, l_out_size);
- //size_t l_enc_size = dap_enc_base64_encode(l_data[i].value, l_data[i].value_len, l_value_enc_str, DAP_ENC_DATA_TYPE_B64);
-
+ dap_enc_base64_encode(l_data[i].value, l_data[i].value_len, l_value_enc_str, DAP_ENC_DATA_TYPE_B64);
struct json_object *jobj = json_object_new_object();
json_object_object_add(jobj, "id", json_object_new_int64((int64_t)l_data[i].id));
json_object_object_add(jobj, "key", json_object_new_string(l_data[i].key));
@@ -4431,6 +4288,7 @@ int cmd_gdb_export(int argc, char ** argv, char ** a_str_reply)
json_object_array_add(l_json, l_json_group_inner);
dap_store_obj_free(l_data, l_data_size);
}
+ dap_list_free_full(l_groups_list, free);
if (json_object_to_file(l_path, l_json) == -1) {
#if JSON_C_MINOR_VERSION<15
log_it(L_CRITICAL, "Couldn't export JSON to file, error code %d", errno );
@@ -4505,9 +4363,9 @@ int cmd_gdb_import(int argc, char ** argv, char ** a_str_reply)
l_group_store[j].timestamp = json_object_get_int64(l_ts);
l_group_store[j].value_len = (uint64_t)json_object_get_int64(l_value_len);
l_group_store[j].type = 'a';
- //const char *l_value_str = json_object_get_string(l_value);
+ const char *l_value_str = json_object_get_string(l_value);
char *l_val = DAP_NEW_Z_SIZE(char, l_group_store[j].value_len);
- //size_t l_dec_size = dap_enc_base64_decode(l_value_str, strlen(l_value_str), l_val, DAP_ENC_DATA_TYPE_B64);
+ dap_enc_base64_decode(l_value_str, strlen(l_value_str), l_val, DAP_ENC_DATA_TYPE_B64);
l_group_store[j].value = (uint8_t*)l_val;
}
if (dap_chain_global_db_driver_appy(l_group_store, l_records_count)) {
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index accf1657ecf370c428e75e960008ddf9deb441c6..87d243c677ad6638ecececc2e3b78501719ee530 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -27,7 +27,6 @@
#include <pthread.h>
#include "dap_chain_wallet.h"
-#include "dap_chain_cell.h"
#include "dap_common.h"
#include "dap_enc_base58.h"
#include "dap_strfuncs.h"
@@ -35,6 +34,7 @@
#include "dap_list.h"
#include "dap_hash.h"
+#include "dap_chain_cell.h"
#include "dap_chain_datum.h"
#include "dap_chain_datum_token.h"
#include "dap_chain_datum_tx_items.h"
@@ -47,14 +47,12 @@
// for dap_db_history_filter()
typedef struct dap_tx_data {
dap_chain_hash_fast_t tx_hash;
- char tx_hash_str[70];
char token_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
- //size_t obj_num;
- size_t pos_num;
dap_chain_datum_t *datum;
- dap_chain_addr_t addr;
- bool is_use_all_cur_out;// find cur addr in prev OUT items
UT_hash_handle hh;
+ //useless
+ char tx_hash_str[70];
+ dap_chain_addr_t addr;
} dap_tx_data_t;
typedef struct dap_chain_tx_hash_processed_ht{
@@ -117,16 +115,13 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
l_tx_hash_user_str = dap_strdup(l_tx_hash_str);
else
l_tx_hash_user_str = dap_enc_base58_from_hex_str_to_str(l_tx_hash_str);
- dap_list_t *l_list_tx_any = dap_list_concat(
- dap_chain_datum_tx_items_get(a_datum, TX_ITEM_TYPE_256_TOKEN, NULL),
- dap_chain_datum_tx_items_get(a_datum, TX_ITEM_TYPE_TOKEN, NULL)
- );
+ 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_tx_hash_user_str);
} else {
char buf[50];
- 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_tx_hash_user_str, dap_ctime_r(&l_ts_create, buf),
+ 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_tx_hash_user_str, dap_ctime_r(&l_ts_create, buf),
dap_chain_ledger_tx_get_token_ticker_by_hash(a_ledger, &l_tx_hash));
}
DAP_DELETE(l_tx_hash_user_str);
@@ -141,9 +136,7 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
while(l_tx_items_count < l_tx_items_size){
uint8_t *item = a_datum->tx_items + l_tx_items_count;
size_t l_item_tx_size = dap_chain_datum_item_tx_get_size(item);
-
- dap_chain_tx_item_type_t l_type = dap_chain_datum_tx_item_get_type(item);
- switch(l_type){
+ switch(dap_chain_datum_tx_item_get_type(item)){
case TX_ITEM_TYPE_IN:
l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_tx_in_t*)item)->header.tx_prev_hash);
dap_string_append_printf(a_str_out, "\t IN:\nTx_prev_hash: %s\n"
@@ -156,38 +149,29 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
dap_string_append_printf(a_str_out, "\t OUT:\n"
"\t\t Value: %s (%"DAP_UINT64_FORMAT_U")\n"
"\t\t Address: %s\n",
- dap_chain_balance_to_coins(dap_chain_uint128_from(
- ((dap_chain_tx_out_t*)item)->header.value)
- ),
+ dap_chain_balance_to_coins(dap_chain_uint256_from(
+ ((dap_chain_tx_out_t*)item)->header.value)),
((dap_chain_tx_out_t*)item)->header.value,
dap_chain_addr_to_str(&((dap_chain_tx_out_t*)item)->addr));
break;
- case TX_ITEM_TYPE_256_OUT: { // 256
+ case TX_ITEM_TYPE_OUT_256: { // 256
dap_string_append_printf(a_str_out, "\t OUT 256_t:\n"
"\t\t Value: %s (%s)\n"
"\t\t Address: %s\n",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(
- ((dap_chain_256_tx_out_t*)item)->header.value)
- ),
- dap_chain_u256tostr(((dap_chain_256_tx_out_t*)item)->header.value),
+ dap_chain_balance_to_coins(((dap_chain_256_tx_out_t*)item)->header.value),
+ dap_chain_balance_print(((dap_chain_256_tx_out_t*)item)->header.value),
dap_chain_addr_to_str(&((dap_chain_256_tx_out_t*)item)->addr));
break;
}
- case TX_ITEM_TYPE_256_TOKEN:
case TX_ITEM_TYPE_TOKEN:
l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_tx_token_t*)item)->header.token_emission_hash);
- dap_string_append_printf(a_str_out, "\t TOKEN%s:\n"
+ dap_string_append_printf(a_str_out, "\t TOKEN:\n"
"\t\t ticker: %s \n"
"\t\t token_emission_hash: %s\n"
- "\t\t token_emission_chain_id: 0x%016"DAP_UINT64_FORMAT_x"\n",
- TX_ITEM_TYPE_256_TOKEN == l_type ? " 256_t " : "",
- ((dap_chain_tx_token_t*)item)->header.ticker,
- l_hash_str_tmp,
- ((dap_chain_tx_token_t*)item)->header.token_emission_chain_id.uint64
- );
+ "\t\t token_emission_chain_id: 0x%016"DAP_UINT64_FORMAT_x"\n", ((dap_chain_tx_token_t*)item)->header.ticker, l_hash_str_tmp,
+ ((dap_chain_tx_token_t*)item)->header.token_emission_chain_id.uint64);
DAP_DELETE(l_hash_str_tmp);
break;
- case TX_ITEM_TYPE_256_TOKEN_EXT:
case TX_ITEM_TYPE_TOKEN_EXT:
l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_tx_token_ext_t*)item)->header.ext_tx_hash);
dap_string_append_printf(a_str_out, "\t TOKEN EXT:\n"
@@ -211,55 +195,26 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t sig_size: %u\n", ((dap_chain_tx_sig_t*)item)->header.sig_size);
dap_sign_get_information(l_sign_tmp, a_str_out);
break;
- case TX_ITEM_TYPE_256_RECEIPT:
case TX_ITEM_TYPE_RECEIPT:
- if ( l_type == TX_ITEM_TYPE_256_RECEIPT) // u256_t value_datoshi
- dap_string_append_printf(a_str_out, "\t Receipt:\n"
- "\t\t size: %u\n"
- "\t\t ext size:%u\n"
- "\t\t Info:"
- "\t\t\t units: 0x%016"DAP_UINT64_FORMAT_x"\n"
- "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
- "\t\t\t units type: %s \n"
- "\t\t\t value: %s (%"DAP_UINT64_FORMAT_U")\n",
- ((dap_chain_datum_tx_receipt_t*)item)->size,
- ((dap_chain_datum_tx_receipt_t*)item)->exts_size,
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units,
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.srv_uid.uint64,
- serv_unit_enum_to_str(
- &((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units_type.enm
- ),
- dap_chain_balance_to_coins(
- dap_chain_uint128_from_uint256(
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi_256
- )
- ),
- dap_chain_u256tostr(((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi_256)
- );
- else // u64_t value_datoshi
- dap_string_append_printf(a_str_out, "\t Receipt:\n"
- "\t\t size: %u\n"
- "\t\t ext size:%u\n"
- "\t\t Info:"
- "\t\t\t units: 0x%016"DAP_UINT64_FORMAT_x"\n"
- "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
- "\t\t\t units type: %s \n"
- "\t\t\t value: %s (%"DAP_UINT64_FORMAT_U")\n",
- ((dap_chain_datum_tx_receipt_t*)item)->size,
- ((dap_chain_datum_tx_receipt_t*)item)->exts_size,
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units,
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.srv_uid.uint64,
- serv_unit_enum_to_str(
- &((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units_type.enm
- ),
- dap_chain_balance_to_coins(
- dap_chain_uint128_from(
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi
- )
- ),
- ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi
- );
-
+ dap_string_append_printf(a_str_out, "\t Receipt:\n"
+ "\t\t size: %u\n"
+ "\t\t ext size:%u\n"
+ "\t\t Info:"
+ "\t\t\t units: 0x%016"DAP_UINT64_FORMAT_x"\n"
+ "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
+ "\t\t\t units type: %s \n"
+ "\t\t\t value: %s (%s)\n",
+ ((dap_chain_datum_tx_receipt_t*)item)->size,
+ ((dap_chain_datum_tx_receipt_t*)item)->exts_size,
+ ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units,
+ ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.srv_uid.uint64,
+ serv_unit_enum_to_str(
+ &((dap_chain_datum_tx_receipt_t*)item)->receipt_info.units_type.enm
+ ),
+ dap_chain_balance_to_coins(
+ ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi),
+ dap_chain_balance_print(
+ ((dap_chain_datum_tx_receipt_t*)item)->receipt_info.value_datoshi));
if (((dap_chain_datum_tx_receipt_t*)item)->exts_size == sizeof(dap_sign_t) + sizeof(dap_sign_t)){
dap_sign_t *l_provider = DAP_NEW_Z(dap_sign_t);
memcpy(l_provider, ((dap_chain_datum_tx_receipt_t*)item)->exts_n_signs, sizeof(dap_sign_t));
@@ -317,12 +272,11 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t\t value: %s (%"DAP_UINT64_FORMAT_U")\n"
"\t\t\t subtype: %s\n"
"\t\t SubType:\n",
- dap_ctime_r((time_t*)((dap_chain_tx_out_cond_t*)item)->header.ts_expires, l_tmp_buf),
- dap_chain_balance_to_coins(
- dap_chain_uint128_from(((dap_chain_tx_out_cond_t*)item)->header.value)
- ),
- ((dap_chain_tx_out_cond_t*)item)->header.value,
- dap_chain_tx_out_cond_subtype_to_str(((dap_chain_tx_out_cond_t*)item)->header.subtype));
+ dap_ctime_r((time_t *)&((dap_chain_tx_out_cond_t*)item)->header.ts_expires, l_tmp_buf),
+ dap_chain_balance_to_coins(dap_chain_uint256_from(
+ ((dap_chain_tx_out_cond_old_t*)item)->header.value)),
+ ((dap_chain_tx_out_cond_old_t*)item)->header.value,
+ dap_chain_tx_out_cond_subtype_to_str(((dap_chain_tx_out_cond_old_t*)item)->header.subtype));
switch (((dap_chain_tx_out_cond_t*)item)->header.subtype) {
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:
l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash);
@@ -330,71 +284,63 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t pkey: %s\n"
"\t\t\t max price: %s (%"DAP_UINT64_FORMAT_U") \n",
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit.uint32,
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.srv_uid.uint64,
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_pay.unit.uint32,
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_pay.srv_uid.uint64,
l_hash_str_tmp,
- dap_chain_balance_to_coins(dap_chain_uint128_from(
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi)
- ),
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi);
+ dap_chain_balance_to_coins(dap_chain_uint256_from(
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_pay.unit_price_max_datoshi)),
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_pay.unit_price_max_datoshi);
DAP_FREE(l_hash_str_tmp);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE:
dap_string_append_printf(a_str_out, "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t addr: %s\n"
"\t\t\t value: %Lf",
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.srv_uid.uint64,
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_stake.srv_uid.uint64,
dap_chain_addr_to_str(
- &((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.fee_addr
+ &((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_stake.fee_addr
),
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.fee_value);
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_stake.fee_value);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE:
dap_string_append_printf(a_str_out, "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t net id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t token: %s\n"
"\t\t\t value: %s (%"DAP_UINT64_FORMAT_U")\n",
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.srv_uid.uint64,
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.net_id.uint64,
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.token,
- dap_chain_balance_to_coins(
- dap_chain_uint128_from(
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.value
- )
- ),
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.value);
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_xchange.srv_uid.uint64,
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_xchange.net_id.uint64,
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_xchange.token,
+ dap_chain_balance_to_coins(dap_chain_uint256_from(
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_xchange.value)),
+ ((dap_chain_tx_out_cond_old_t*)item)->subtype.srv_xchange.value);
break;
default: break;
}
break;
- case TX_ITEM_TYPE_256_OUT_COND: // 256
+ case TX_ITEM_TYPE_OUT_256_COND: // 256
dap_string_append_printf(a_str_out, "\t OUT 256_t COND:\n"
"\t Header:\n"
"\t\t\t ts_expires: %s\t"
"\t\t\t value: %s (%s)\n"
"\t\t\t subtype: %s\n"
"\t\t SubType:\n",
- dap_ctime_r((time_t*)((dap_chain_256_tx_out_cond_t*)item)->header.ts_expires, l_tmp_buf),
- dap_chain_balance_to_coins(
- dap_chain_uint128_from_uint256(((dap_chain_256_tx_out_cond_t*)item)->header.value)
- ),
- dap_chain_u256tostr(((dap_chain_256_tx_out_cond_t*)item)->header.value),
- dap_chain_tx_out_cond_subtype_to_str(((dap_chain_256_tx_out_cond_t*)item)->header.subtype)
+ dap_ctime_r((time_t*)((dap_chain_tx_out_cond_t*)item)->header.ts_expires, l_tmp_buf),
+ dap_chain_balance_to_coins(((dap_chain_tx_out_cond_t*)item)->header.value),
+ dap_chain_balance_print(((dap_chain_tx_out_cond_t*)item)->header.value),
+ dap_chain_tx_out_cond_subtype_to_str(((dap_chain_tx_out_cond_t*)item)->header.subtype)
);
- switch (((dap_chain_256_tx_out_cond_t*)item)->header.subtype) {
+ switch (((dap_chain_tx_out_cond_t*)item)->header.subtype) {
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:
- l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash);
+ l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash);
dap_string_append_printf(a_str_out, "\t\t\t unit: 0x%08x\n"
"\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t pkey: %s\n"
"\t\t\t max price: %s (%s) \n",
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.unit.uint32,
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.srv_uid.uint64,
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit.uint32,
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.srv_uid.uint64,
l_hash_str_tmp,
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi)
- ),
- dap_chain_u256tostr(((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi)
+ dap_chain_balance_to_coins(((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi),
+ dap_chain_balance_print(((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi)
);
DAP_FREE(l_hash_str_tmp);
break;
@@ -402,11 +348,11 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
dap_string_append_printf(a_str_out, "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t addr: %s\n"
"\t\t\t value: %Lf",
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_stake.srv_uid.uint64,
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.srv_uid.uint64,
dap_chain_addr_to_str(
- &((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_stake.fee_addr
+ &((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.fee_addr
),
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_stake.fee_value
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.fee_value
);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE:
@@ -414,43 +360,24 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t\t net id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t token: %s\n"
"\t\t\t value: %s (%s)\n",
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.srv_uid.uint64,
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.net_id.uint64,
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.token,
- dap_chain_balance_to_coins(
- dap_chain_uint128_from_uint256(
- ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.value
- )
- ),
- dap_chain_u256tostr(((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.value)
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.srv_uid.uint64,
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.net_id.uint64,
+ ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.token,
+ dap_chain_balance_to_coins(((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.value),
+ dap_chain_balance_print(((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.value)
);
break;
}
break;
- case TX_ITEM_TYPE_OUT_EXT:
- dap_string_append_printf(a_str_out, "\t OUT EXT:\n"
- "\t\t Addr: %s\n"
- "\t\t Token: %s\n"
- "\t\t Value: %s (%"DAP_UINT64_FORMAT_U")\n",
- dap_chain_addr_to_str(&((dap_chain_tx_out_ext_t*)item)->addr),
- ((dap_chain_tx_out_ext_t*)item)->token,
- dap_chain_balance_to_coins(dap_chain_uint128_from(
- ((dap_chain_tx_out_ext_t*)item)->header.value)
- ),
- ((dap_chain_tx_out_ext_t*)item)->header.value
- );
- break;
- case TX_ITEM_TYPE_256_OUT_EXT: // 256
+ case TX_ITEM_TYPE_OUT_EXT: // 256
dap_string_append_printf(a_str_out, "\t OUT 256_t EXT:\n"
"\t\t Addr: %s\n"
"\t\t Token: %s\n"
"\t\t Value: %s (%s)\n",
- dap_chain_addr_to_str(&((dap_chain_256_tx_out_ext_t*)item)->addr),
- ((dap_chain_256_tx_out_ext_t*)item)->token,
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(
- ((dap_chain_256_tx_out_ext_t*)item)->header.value)
- ),
- dap_chain_u256tostr(((dap_chain_256_tx_out_ext_t*)item)->header.value)
+ dap_chain_addr_to_str(&((dap_chain_tx_out_ext_t*)item)->addr),
+ ((dap_chain_tx_out_ext_t*)item)->token,
+ dap_chain_balance_to_coins(((dap_chain_tx_out_ext_t*)item)->header.value),
+ dap_chain_balance_print(((dap_chain_tx_out_ext_t*)item)->header.value)
);
break;
default:
@@ -464,25 +391,6 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
dap_string_append_printf(a_str_out, "\n");
}
-/*static char* dap_db_new_history_timestamp()
-{
- static pthread_mutex_t s_mutex = PTHREAD_MUTEX_INITIALIZER;
- // get unique key
- pthread_mutex_lock(&s_mutex);
- static time_t s_last_time = 0;
- static uint64_t s_suffix = 0;
- time_t l_cur_time = time(NULL);
- if(s_last_time == l_cur_time)
- s_suffix++;
- else {
- s_suffix = 0;
- s_last_time = l_cur_time;
- }
- char *l_str = dap_strdup_printf("%lld_%lld", (uint64_t) l_cur_time, s_suffix);
- pthread_mutex_unlock(&s_mutex);
- return l_str;
-}*/
-
// for dap_db_history_tx & dap_db_history_addr()
static dap_chain_datum_t* get_prev_tx(dap_tx_data_t *a_tx_data)
{
@@ -518,16 +426,13 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
while(l_atom && l_atom_size) {
dap_chain_datum_t *l_datum = (dap_chain_datum_t*) l_atom;
- if(!l_datum && (l_datum->header.type_id != DAP_CHAIN_DATUM_TX && l_datum->header.type_id != DAP_CHAIN_DATUM_256_TX ) ) {
+ if (!l_datum || (l_datum->header.type_id != DAP_CHAIN_DATUM_TX)) {
// go to next transaction
l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
continue;
}
- bool l_type_256 = false;
- if ( l_datum->header.type_id == DAP_CHAIN_DATUM_256_TX )
- l_type_256 = true;
dap_tx_data_t *l_tx_data = NULL;
@@ -535,22 +440,16 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
// find Token items - present in emit transaction
- // dap_list_t *l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
-
dap_list_t *l_list_tx_token;
- if ( l_type_256 ) // 256
- l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_256_TOKEN, NULL);
- else
- l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
+ l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
// find OUT items
- // dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
-
- dap_list_t *l_list_out_items;
- if ( l_type_256 ) // 256
- l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_256_OUT, NULL);
- else
- l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
+ bool l_type_256 = false;
+ dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
+ if (!l_list_out_items) {
+ l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT_256, NULL);
+ l_type_256 = true;
+ }
dap_list_t *l_list_tmp = l_list_out_items;
@@ -570,7 +469,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
memcpy(&l_tx_data->addr, &l_tx_out->addr, sizeof(dap_chain_addr_t));
else
memcpy(&l_tx_data->addr, &l_tx_out_256->addr, sizeof(dap_chain_addr_t));
-
+
dap_chain_hash_fast_to_str(&l_tx_data->tx_hash, l_tx_data->tx_hash_str,
sizeof(l_tx_data->tx_hash_str));
//l_tx_data->pos_num = l_count;
@@ -640,7 +539,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
// find all OUT items in transaction
if ( l_type_256 )
- l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_256_OUT, NULL);
+ l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT_256, NULL);
else
l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
l_list_tmp = l_list_out_items;
@@ -653,13 +552,13 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
const char *l_token_str = NULL;
if(l_tx_data)
l_token_str = l_tx_data->token_ticker;
- char *l_dst_to_str = (l_tx_out) ? dap_chain_addr_to_str(&l_tx_out->addr) :
+ char *l_dst_to_str = (l_tx_out) ? dap_chain_addr_to_str(&l_tx_out->addr) :
(l_tx_out_256) ? dap_chain_addr_to_str(&l_tx_out_256->addr) : NULL;
if(l_tx_out || l_tx_out_256) {
if ( l_type_256 ) // 256
- dap_string_append_printf(l_str_out, " OUT 256_t item %s %s to %s\n",
- dap_chain_u256tostr(l_tx_out_256->header.value),
+ dap_string_append_printf(l_str_out, " OUT 256bit item %s %s to %s\n",
+ dap_chain_balance_print(l_tx_out_256->header.value),
dap_strlen(l_token_str) > 0 ? l_token_str : "?",
l_dst_to_str ? l_dst_to_str : "?"
);
@@ -711,15 +610,15 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
if ( l_type_256 ) { // 256
// find OUT items in prev datum
dap_list_t *l_list_out_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
- TX_ITEM_TYPE_256_OUT, NULL);
+ TX_ITEM_TYPE_OUT_256, NULL);
// find OUT item for IN item;
dap_list_t *l_list_out_prev_item = dap_list_nth(l_list_out_prev_items,
l_tx_in->header.tx_out_prev_idx);
dap_chain_256_tx_out_t *l_tx_prev_out =
l_list_out_prev_item ? (dap_chain_256_tx_out_t*)l_list_out_prev_item->data : NULL;
// print value from prev out item
- dap_string_append_printf(l_str_out, " prev OUT 256_t item value=%s",
- l_tx_prev_out ? dap_chain_u256tostr(l_tx_prev_out->header.value) : "0");
+ dap_string_append_printf(l_str_out, " prev OUT 256bitt item value=%s",
+ l_tx_prev_out ? dap_chain_balance_print(l_tx_prev_out->header.value) : "0");
} else {
dap_list_t *l_list_out_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
TX_ITEM_TYPE_OUT, NULL);
@@ -728,7 +627,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
dap_chain_tx_out_t *l_tx_prev_out =
l_list_out_prev_item ? (dap_chain_tx_out_t*)l_list_out_prev_item->data : NULL;
dap_string_append_printf(l_str_out, " prev OUT item value=%"DAP_UINT64_FORMAT_U,
- l_tx_prev_out ? l_tx_prev_out->header.value : 0);
+ l_tx_prev_out ? l_tx_prev_out->header.value : 0);
}
}
@@ -771,6 +670,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
return l_ret_str;
}
+
/**
* @brief dap_db_history_addr
* Get data according the history log
@@ -786,384 +686,141 @@ char* dap_db_history_addr(dap_chain_addr_t * a_addr, dap_chain_t * a_chain, cons
dap_string_t *l_str_out = dap_string_new(NULL);
dap_tx_data_t *l_tx_data_hash = NULL;
- dap_chain_cell_t *l_cell = a_chain->cells;
- do {
- // load transactions
- dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, l_cell->id);
- size_t l_atom_size=0;
- dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
- if (!l_atom) {
- return NULL;
+ // load transactions
+ dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain, a_chain->cells->id);
+ size_t l_atom_size=0;
+ dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter, &l_atom_size);
+ if (!l_atom) {
+ return NULL;
+ }
+ while (l_atom && l_atom_size) {
+ size_t l_datums_count = 0;
+ dap_chain_datum_t **l_datums = a_chain->callback_atom_get_datums ? 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);
+ break;
}
- while(l_atom && l_atom_size) {
- size_t l_datums_count =0;
- dap_chain_datum_t **l_datums = a_chain->callback_atom_get_datums ? 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);
- break;
+ for (size_t d = 0; d < l_datums_count; d++) {
+ dap_chain_datum_t *l_datum = l_datums && l_datums_count ? l_datums[d] : NULL;
+ if (!l_datum || l_datum->header.type_id != DAP_CHAIN_DATUM_TX) {
+ // go to next transaction
+ continue;
+ }
+ dap_tx_data_t *l_tx_data = DAP_NEW_Z(dap_tx_data_t);
+ // transaction
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t *)l_datum->data;
+
+ // find Token items - present in base transaction
+ dap_list_t *l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
+ // save token name
+ if (l_list_tx_token) {
+ strcpy(l_tx_data->token_ticker,
+ ((dap_chain_tx_token_t *)l_list_tx_token->data)->header.ticker);
+ dap_list_free(l_list_tx_token);
}
- for (size_t d=0; d< l_datums_count; d++){
- dap_chain_datum_t *l_datum = l_datums && l_datums_count ? l_datums[d] :NULL;
- if(!l_datum || l_datum->header.type_id != DAP_CHAIN_DATUM_TX) {
- // go to next transaction
- l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
+ dap_list_t *l_list_in_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_IN, NULL);
+ if (!l_list_in_items) { // a bad tx
+ DAP_DELETE(l_tx_data);
+ continue;
+ }
+ // all in items should be from the same address
+ dap_chain_tx_in_t *l_tx_in = (dap_chain_tx_in_t *)l_list_in_items->data;
+ dap_chain_hash_fast_t *l_tx_prev_hash = &l_tx_in->header.tx_prev_hash;
+ dap_chain_addr_t *l_src_addr = NULL;
+ char *l_src_addr_str = NULL;
+ if (!dap_hash_fast_is_blank(l_tx_prev_hash)) {
+ dap_tx_data_t *l_tx_data_prev = NULL;
+ HASH_FIND(hh, l_tx_data_hash, l_tx_prev_hash, sizeof(dap_chain_hash_fast_t), l_tx_data_prev);
+ if (!l_tx_data_prev) { // prev tx not found - no info for history
+ DAP_DELETE(l_tx_data);
continue;
}
- // transaction
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
- dap_list_t *l_records_out = NULL;
- // transaction time
- char *l_time_str = NULL;
- {
- if(l_tx->header.ts_created > 0) {
- time_t rawtime = (time_t) l_tx->header.ts_created;
- struct tm * timeinfo;
- timeinfo = localtime(&rawtime);
- if(timeinfo)
- l_time_str = dap_strdup(asctime(timeinfo));
- }
- else
- l_time_str = dap_strdup(" ");
- }
-
- // find Token items - present in emit transaction
- dap_list_t *l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
-
- // list of dap_tx_data_t*; info about OUT item in current transaction
- dap_list_t *l_list_out_info = NULL;
-
- // find OUT items
- dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
- dap_list_t *l_list_out_items_tmp = l_list_out_items;
- while(l_list_out_items_tmp) {
- const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_out_items_tmp->data;
- // save OUT item l_tx_out
- {
- // save tx hash
- // info about OUT item in current transaction
- dap_tx_data_t *l_tx_data = DAP_NEW_Z(dap_tx_data_t);
- dap_chain_hash_fast_t l_tx_hash;
- dap_hash_fast(l_tx, dap_chain_datum_tx_get_size(l_tx), &l_tx_hash);
- memcpy(&l_tx_data->tx_hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t));
- memcpy(&l_tx_data->addr, &l_tx_out->addr, sizeof(dap_chain_addr_t));
- dap_chain_hash_fast_to_str(&l_tx_data->tx_hash, l_tx_data->tx_hash_str, sizeof(l_tx_data->tx_hash_str));
- l_tx_data->datum = DAP_NEW_SIZE(dap_chain_datum_t, l_atom_size);
- memcpy(l_tx_data->datum, l_datum, l_atom_size);
- // save token name
- if(l_tx_data && l_list_tx_token) {
- dap_chain_tx_token_t *tk = l_list_tx_token->data;
- memcpy(l_tx_data->token_ticker, tk->header.ticker, sizeof(l_tx_data->token_ticker));
- }
- HASH_ADD(hh, l_tx_data_hash, tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_data);
+ strncpy(l_tx_data->token_ticker, l_tx_data_prev->token_ticker, DAP_CHAIN_TICKER_SIZE_MAX);
+ dap_chain_datum_tx_t *l_tx_prev = (dap_chain_datum_tx_t *)l_tx_data_prev->datum->data;
+ dap_list_t *l_list_prev_out_items = dap_chain_datum_tx_items_get(l_tx_prev, TX_ITEM_TYPE_OUT, NULL);
+ dap_list_t *l_list_out_prev_item = dap_list_nth(l_list_prev_out_items, l_tx_in->header.tx_out_prev_idx);
+ l_src_addr = &((dap_chain_tx_out_t *)l_list_out_prev_item->data)->addr;
+ l_src_addr_str = dap_chain_addr_to_str(l_src_addr);
+ dap_list_free(l_list_prev_out_items);
+ }
+ dap_list_free(l_list_in_items);
- // save OUT items to list
- l_records_out = dap_list_append(l_records_out, (void*) l_tx_out);
- // save info about OUT items to list
- l_list_out_info = dap_list_append(l_list_out_info, (void*) l_tx_data);
+ dap_hash_fast(l_tx, dap_chain_datum_tx_get_size(l_tx), &l_tx_data->tx_hash);
+ // transaction time
+ char *l_time_str = NULL;
+ {
+ if (l_tx->header.ts_created > 0) {
+ time_t rawtime = (time_t)l_tx->header.ts_created;
+ struct tm *timeinfo;
+ timeinfo = localtime(&rawtime);
+ if(timeinfo)
+ l_time_str = dap_strdup(asctime(timeinfo));
+ } else
+ l_time_str = dap_strdup(" ");
+ }
+ char *l_tx_hash_str;
+ if (!dap_strcmp(a_hash_out_type, "hex"))
+ l_tx_hash_str = dap_hash_fast_to_str_new(&l_tx_data->tx_hash);
+ else
+ l_tx_hash_str = dap_enc_base58_encode_to_str(&l_tx_data->tx_hash_str, sizeof(dap_chain_hash_fast_t));
+ // find OUT items
+ bool l_header_printed = false;
+ dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
+ for (dap_list_t *l_list_out = l_list_out_items; l_list_out; l_list_out = dap_list_next(l_list_out)) {
+ dap_chain_tx_out_t *l_tx_out = (dap_chain_tx_out_t *)l_list_out->data;
+ if (l_src_addr && !memcmp(&l_tx_out->addr, l_src_addr, sizeof(dap_chain_addr_t)))
+ continue; // send to self
+ if (l_src_addr && !memcmp(l_src_addr, a_addr, sizeof(dap_chain_addr_t))) {
+ if (!l_header_printed) {
+ dap_string_append_printf(l_str_out, "TX hash %s\n\t%s", l_tx_hash_str, l_time_str);
+ l_header_printed = true;
}
- l_list_out_items_tmp = dap_list_next(l_list_out_items_tmp);
+ char *l_dst_addr_str = dap_chain_addr_to_str(&l_tx_out->addr);
+ dap_string_append_printf(l_str_out, "\tsend %"DAP_UINT64_FORMAT_U" %s to %s\n",
+ l_tx_out->header.value,
+ l_tx_data->token_ticker,
+ l_dst_addr_str);
+ DAP_DELETE(l_dst_addr_str);
}
-
- // find IN items
- dap_list_t *l_list_in_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_IN, NULL);
- dap_list_t *l_list_in_items_tmp = l_list_in_items;
- // find cur addr in prev OUT items
- //bool l_is_use_all_cur_out = false;
- {
- while(l_list_in_items_tmp) {
- const dap_chain_tx_in_t *l_tx_in = (const dap_chain_tx_in_t*) l_list_in_items_tmp->data;
- dap_chain_hash_fast_t tx_prev_hash = l_tx_in->header.tx_prev_hash;
-
- //find prev OUT item
- dap_tx_data_t *l_tx_data_prev = NULL;
- HASH_FIND(hh, l_tx_data_hash, &tx_prev_hash, sizeof(dap_chain_hash_fast_t), l_tx_data_prev);
- if(l_tx_data_prev != NULL) {
- // fill token in all l_tx_data from prev transaction
-
- dap_list_t *l_list_out_info_tmp = l_list_out_info;
- while(l_list_out_info_tmp) {
- dap_tx_data_t *l_tx_data = (dap_tx_data_t*) l_list_out_info_tmp->data;
- if(l_tx_data) {
- // get token from prev tx
- memcpy(l_tx_data->token_ticker, l_tx_data_prev->token_ticker,
- sizeof(l_tx_data->token_ticker));
- dap_chain_datum_t *l_datum_prev = get_prev_tx(l_tx_data_prev);
- dap_chain_datum_tx_t *l_tx_prev =
- l_datum_prev ? (dap_chain_datum_tx_t*) l_datum_prev->data : NULL;
-
- // find OUT items in prev datum
- dap_list_t *l_list_out_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
- TX_ITEM_TYPE_OUT, NULL);
- // find OUT item for IN item;
- dap_list_t *l_list_out_prev_item = dap_list_nth(l_list_out_prev_items,
- l_tx_in->header.tx_out_prev_idx);
- dap_chain_tx_out_t *l_tx_prev_out =
- l_list_out_prev_item ?
- (dap_chain_tx_out_t*) l_list_out_prev_item->data :
- NULL;
- if(l_tx_prev_out && !memcmp(&l_tx_prev_out->addr, a_addr, sizeof(dap_chain_addr_t)))
- l_tx_data->is_use_all_cur_out = true;
-
- }
- l_list_out_info_tmp = dap_list_next(l_list_out_info_tmp);
- }
- }
- l_list_in_items_tmp = dap_list_next(l_list_in_items_tmp);
- }
- // find prev OUT items for IN items
- dap_list_t *l_list_in_items2_tmp = l_list_in_items; // go to begin of list
- while(l_list_in_items2_tmp) {
- const dap_chain_tx_in_t *l_tx_in = (const dap_chain_tx_in_t*) l_list_in_items2_tmp->data;
- dap_chain_hash_fast_t tx_prev_hash = l_tx_in->header.tx_prev_hash;
- // if first transaction - empty prev OUT item
- if(dap_hash_fast_is_blank(&tx_prev_hash)) {
-
- dap_tx_data_t *l_tx_data = NULL;
- dap_list_t *l_list_out_info_tmp = l_list_out_info;
- while(l_list_out_info_tmp) {
- l_tx_data = (dap_tx_data_t*) l_list_out_info_tmp->data;
- if(l_tx_data->token_ticker[0])
- break;
- l_list_out_info_tmp = dap_list_next(l_list_out_info_tmp);
- }
-
- // add emit info to ret string
- if(l_tx_data && !memcmp(&l_tx_data->addr, a_addr, sizeof(dap_chain_addr_t))) {
- dap_list_t *l_records_tmp = l_records_out;
- while(l_records_tmp) {
- char *tx_hash_str;
- if(!dap_strcmp(a_hash_out_type,"hex"))
- tx_hash_str = dap_strdup( l_tx_data->tx_hash_str);
- else
- tx_hash_str = dap_enc_base58_from_hex_str_to_str( l_tx_data->tx_hash_str);
- const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_records_tmp->data;
-
- if(!dap_strcmp(a_hash_out_type,"hex")){
- dap_string_append_printf(l_str_out, "tx hash %s \n emit %"DAP_UINT64_FORMAT_U" %s\n",
- tx_hash_str,//l_tx_data->tx_hash_str,
- l_tx_out->header.value,
- l_tx_data->token_ticker);
- }
- else {
- dap_string_append_printf(l_str_out, "tx hash %s \n emit %"DAP_UINT64_FORMAT_U" %s\n",
- l_tx_data->tx_hash_str,
- l_tx_out->header.value,
- l_tx_data->token_ticker);
- }
- DAP_DELETE(tx_hash_str);
- l_records_tmp = dap_list_next(l_records_tmp);
- }
- }
- //dap_list_free(l_records_out);
- }
- // in other transactions except first one
- else {
- //find prev OUT item
- dap_tx_data_t *l_tx_data_prev = NULL;
- HASH_FIND(hh, l_tx_data_hash, &tx_prev_hash, sizeof(dap_chain_hash_fast_t), l_tx_data_prev);
- if(l_tx_data_prev != NULL) {
- char *l_src_str = NULL;
- bool l_src_str_is_cur = false;
-
- dap_tx_data_t *l_tx_data = NULL;
- dap_list_t *l_list_out_info_tmp = l_list_out_info;
- while(l_list_out_info_tmp) {
- l_tx_data = (dap_tx_data_t*) l_list_out_info_tmp->data;
- if(l_tx_data->token_ticker[0])
- break;
- l_list_out_info_tmp = dap_list_next(l_list_out_info_tmp);
- }
- if(l_tx_data) {
- // get token from prev tx
- memcpy(l_tx_data->token_ticker, l_tx_data_prev->token_ticker,
- sizeof(l_tx_data->token_ticker));
-
- dap_chain_datum_t *l_datum_prev = get_prev_tx(l_tx_data_prev);
- dap_chain_datum_tx_t *l_tx_prev =
- l_datum_prev ? (dap_chain_datum_tx_t*) l_datum_prev->data : NULL;
-
- // find OUT items in prev datum
- dap_list_t *l_list_out_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
- TX_ITEM_TYPE_OUT, NULL);
- // find OUT item for IN item;
- dap_list_t *l_list_out_prev_item = dap_list_nth(l_list_out_prev_items,
- l_tx_in->header.tx_out_prev_idx);
- dap_chain_tx_out_t *l_tx_prev_out =
- l_list_out_prev_item ?
- (dap_chain_tx_out_t*) l_list_out_prev_item->data :
- NULL;
- // if use src addr
- bool l_is_use_src_addr = false;
- // find source addrs
- dap_string_t *l_src_addr = dap_string_new(NULL);
- {
- // find IN items in prev datum - for get destination addr
- dap_list_t *l_list_in_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
- TX_ITEM_TYPE_IN, NULL);
- dap_list_t *l_list_tmp = l_list_in_prev_items;
- while(l_list_tmp) {
- dap_chain_tx_in_t *l_tx_prev_in = l_list_tmp->data;
- dap_chain_hash_fast_t l_tx_prev_prev_hash =
- l_tx_prev_in->header.tx_prev_hash;
- //find prev OUT item
- dap_tx_data_t *l_tx_data_prev_prev = NULL;
- HASH_FIND(hh, l_tx_data_hash, &l_tx_prev_prev_hash,
- sizeof(dap_chain_hash_fast_t), l_tx_data_prev_prev);
- if(l_tx_data_prev_prev) {
- // if use src addr
- if(l_tx_data_prev_prev &&
- !memcmp(&l_tx_data_prev_prev->addr, a_addr,
- sizeof(dap_chain_addr_t)))
- l_is_use_src_addr = true;
- char *l_str = dap_chain_addr_to_str(&l_tx_data_prev_prev->addr);
- if(l_src_addr->len > 0)
- dap_string_append_printf(l_src_addr, "\n %s", l_str);
- else
- dap_string_append_printf(l_src_addr, "%s", l_str); // first record
- DAP_DELETE(l_str);
- }
- l_list_tmp = dap_list_next(l_list_tmp);
- }
- }
-
- l_src_str_is_cur = l_is_use_src_addr;
- if(l_src_addr->len <= 1) {
- l_src_str =
- (l_tx_data) ? dap_chain_addr_to_str(&l_tx_data->addr) :
- NULL;
- if(l_tx_prev_out && !memcmp(&l_tx_prev_out->addr, a_addr, sizeof(dap_chain_addr_t)))
- l_src_str_is_cur = true;
- dap_string_free(l_src_addr, true);
- }
- else
- l_src_str = dap_string_free(l_src_addr, false);
-
- if(l_tx_prev_out) {
- char *l_dst_to_str = dap_chain_addr_to_str(&l_tx_prev_out->addr);
- // if use dst addr
- bool l_is_use_dst_addr = false;
- if(!memcmp(&l_tx_prev_out->addr, a_addr, sizeof(dap_chain_addr_t)))
- l_is_use_dst_addr = true;
- char *tx_hash_str;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- tx_hash_str = dap_strdup(l_tx_data->tx_hash_str);
- else
- tx_hash_str = dap_enc_base58_from_hex_str_to_str(l_tx_data->tx_hash_str);
- if(l_is_use_src_addr && !l_is_use_dst_addr) {
- dap_string_append_printf(l_str_out,
- "tx hash %s \n %s in send %"DAP_UINT64_FORMAT_U" %s from %s\n to %s\n",
- tx_hash_str,//l_tx_data->tx_hash_str,
- l_time_str ? l_time_str : "",
- l_tx_prev_out->header.value,
- l_tx_data->token_ticker,
- l_src_str ? l_src_str : "",
- l_dst_to_str);
- } else if(l_is_use_dst_addr && !l_is_use_src_addr) {
- if(!l_src_str_is_cur)
- dap_string_append_printf(l_str_out,
- "tx hash %s \n %s in recv %"DAP_UINT64_FORMAT_U" %s from %s\n",
- tx_hash_str,//l_tx_data->tx_hash_str,
- l_time_str ? l_time_str : "",
- l_tx_prev_out->header.value,
- l_tx_data->token_ticker,
- l_src_str ? l_src_str : "");
- }
- DAP_DELETE(tx_hash_str);
- DAP_DELETE(l_dst_to_str);
- }
- dap_list_free(l_list_out_prev_items);
- }
-
- // OUT items
- dap_list_t *l_records_tmp = l_records_out;
- while(l_records_tmp) {
-
- const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_records_tmp->data;
-
- if(( l_tx_data && l_tx_data->is_use_all_cur_out )
- || !memcmp(&l_tx_out->addr, a_addr, sizeof(dap_chain_addr_t))) {
-
- char *l_addr_str = (l_tx_out) ? dap_chain_addr_to_str(&l_tx_out->addr) : NULL;
-
- char *tx_hash_str;
- if(!dap_strcmp(a_hash_out_type, "hex"))
- tx_hash_str = dap_strdup(l_tx_data->tx_hash_str);
- else
- tx_hash_str = dap_enc_base58_from_hex_str_to_str(l_tx_data->tx_hash_str);
- if(l_tx_out && a_addr && memcmp(&l_tx_out->addr, a_addr, sizeof(dap_chain_addr_t))==0) {
- if(!l_src_str_is_cur)
- dap_string_append_printf(l_str_out,
- "tx hash %s \n %s recv %"DAP_UINT64_FORMAT_U" %s from %s\n",
- tx_hash_str,//l_tx_data->tx_hash_str,
- l_time_str ? l_time_str : "",
- l_tx_out->header.value,
- l_tx_data_prev->token_ticker,
- l_src_str ? l_src_str : "?");
- // break search prev OUT items for IN items
- l_list_in_items2_tmp = NULL;
- }
- else {
- dap_string_append_printf(l_str_out,
- "tx hash %s \n %s send %"DAP_UINT64_FORMAT_U" %s to %s\n",
- tx_hash_str,//l_tx_data->tx_hash_str,
- l_time_str ? l_time_str : "",
- l_tx_out->header.value,
- l_tx_data_prev->token_ticker,
- l_addr_str ? l_addr_str : "");
- l_list_in_items2_tmp = NULL;
- }
- DAP_DELETE(tx_hash_str);
- DAP_DELETE(l_addr_str);
- }
-
- l_records_tmp = dap_list_next(l_records_tmp);
- }
- //dap_list_free(l_records_out);
- DAP_DELETE(l_src_str);
-
- }
- }
- l_list_in_items2_tmp = dap_list_next(l_list_in_items2_tmp);
+ if (!memcmp(&l_tx_out->addr, a_addr, sizeof(dap_chain_addr_t))) {
+ if (!l_header_printed) {
+ dap_string_append_printf(l_str_out, "TX hash %s\n\t%s", l_tx_hash_str, l_time_str);
+ l_header_printed = true;
}
- // l_list_in_items_tmp = dap_list_next(l_list_in_items_tmp);
- // }
+ dap_string_append_printf(l_str_out, "\trecv %"DAP_UINT64_FORMAT_U" %s from %s\n",
+ l_tx_out->header.value,
+ l_tx_data->token_ticker,
+ l_src_addr ? l_src_addr_str : "emission");
}
-
- if(l_list_tx_token)
- dap_list_free(l_list_tx_token);
- if(l_list_out_items)
- dap_list_free(l_list_out_items);
- if(l_list_in_items)
- dap_list_free(l_list_in_items);
- dap_list_free(l_records_out);
- dap_list_free(l_list_out_info);
- DAP_DELETE(l_time_str);
-
- // go to next transaction
- l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
}
- DAP_DELETE(l_datums);
- }
-
- // delete hashes
- dap_tx_data_t *l_iter_current, *l_item_tmp;
- HASH_ITER(hh, l_tx_data_hash , l_iter_current, l_item_tmp)
- {
- // delete datum
- DAP_DELETE(l_iter_current->datum);
- // delete struct
- DAP_DELETE(l_iter_current);
- HASH_DEL(l_tx_data_hash, l_iter_current);
+ dap_list_free(l_list_out_items);
+ DAP_DELETE(l_src_addr_str);
+ DAP_DELETE(l_tx_hash_str);
+ DAP_DELETE(l_time_str);
+
+ size_t l_datum_size = dap_chain_datum_tx_get_size(l_tx) + sizeof(dap_chain_datum_t);
+ l_tx_data->datum = DAP_NEW_SIZE(dap_chain_datum_t, l_datum_size);
+ memcpy(l_tx_data->datum, l_datum, l_datum_size); // for GDB chains with data replace with each itreation
+ HASH_ADD(hh, l_tx_data_hash, tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_data);
}
- l_cell = l_cell->hh.next;
- } while (l_cell);
+ DAP_DELETE(l_datums);
+ // go to next atom (event or block)
+ l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
+ }
+ // delete hashes
+ dap_tx_data_t *l_iter_current, *l_item_tmp;
+ HASH_ITER(hh, l_tx_data_hash , l_iter_current, l_item_tmp) {
+ HASH_DEL(l_tx_data_hash, l_iter_current);
+ // delete struct
+ DAP_DELETE(l_iter_current);
+ }
// if no history
if(!l_str_out->len)
- dap_string_append(l_str_out, " empty");
+ dap_string_append(l_str_out, "\tempty");
char *l_ret_str = l_str_out ? dap_string_free(l_str_out, false) : NULL;
return l_ret_str;
}
@@ -1201,7 +858,8 @@ static char* dap_db_history_token_list(dap_chain_t * a_chain, const char *a_toke
// get time of create datum
if (dap_time_to_str_rfc822(l_time_str, 70, l_datum->header.ts_create) < 1)
l_time_str[0] = '\0';
- dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
+ size_t l_token_size = l_datum->header.data_size;
+ dap_chain_datum_token_t *l_token = dap_chain_datum_token_read(l_datum->data, &l_token_size);
if (!a_token_name || !dap_strcmp(l_token->ticker, a_token_name)) {
dap_chain_hash_fast_t l_datum_hash = {};
dap_hash_fast(l_datum, dap_chain_datum_size(l_datum), &l_datum_hash);
@@ -1212,13 +870,13 @@ static char* dap_db_history_token_list(dap_chain_t * a_chain, const char *a_toke
l_out_hash_str = dap_enc_base58_encode_hash_to_str(&l_datum_hash);
dap_string_append(l_str_out, l_out_hash_str);
dap_string_append(l_str_out, "\n");
- dap_string_append_printf(l_str_out, "token %s, created: %s\n", l_token->ticker, l_time_str);
+ 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: // 256
dap_string_append_printf(l_str_out, " total_supply: %s(%s), signs: valid/total %02d/%02d \n",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_private.total_supply_256)),
- dap_chain_u256tostr(l_token->header_private.total_supply_256),
+ dap_chain_balance_to_coins(l_token->header_private.total_supply_256),
+ dap_chain_balance_print(l_token->header_private.total_supply_256),
l_token->header_private.signs_valid, l_token->header_private.signs_total);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
@@ -1235,38 +893,40 @@ static char* dap_db_history_token_list(dap_chain_t * a_chain, const char *a_toke
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_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);
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
+ l_token->header_private_update.tsd_total_size);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: { // 256
char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
- char * l_balance = dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_public.total_supply_256));
+ char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply_256);
dap_string_append_printf(l_str_out,
" total_supply: %s(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_public.total_supply_256)),
- dap_chain_u256tostr(l_token->header_public.total_supply_256),
+ dap_chain_balance_to_coins(l_token->header_public.total_supply_256),
+ dap_chain_balance_print(l_token->header_public.total_supply_256),
l_token->header_public.flags,
- dap_chain_u256tostr(l_token->header_public.premine_supply_256),
+ dap_chain_balance_print(l_token->header_public.premine_supply_256),
l_addr ? l_addr : "-");
DAP_DELETE(l_addr);
DAP_DELETE(l_balance);
}break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_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);
+ char * l_balance = dap_chain_balance_to_coins(dap_chain_uint256_from_uint128(
+ 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",
- dap_chain_balance_to_coins(l_token->header_public.total_supply),
- dap_chain_balance_print(l_token->header_public.total_supply),
+ l_balance,
+ dap_chain_balance_print(dap_chain_uint256_from_uint128(
+ l_token->header_public.total_supply)),
l_token->header_public.flags,
- dap_chain_balance_print(l_token->header_public.premine_supply),
+ dap_chain_balance_print(dap_chain_uint256_from_uint128(
+ 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);
+ 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");
@@ -1350,7 +1010,6 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
switch (l_datum->header.type_id) {
// token
- case DAP_CHAIN_DATUM_256_TOKEN_DECL: // 256
case DAP_CHAIN_DATUM_TOKEN_DECL: {
// no token necessary for addr
if(a_filtr_addr_base58) {
@@ -1369,9 +1028,9 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
switch (l_token->type) {
// Simple private token decl
case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
- dap_string_append_printf(l_str_out, " 256_t total_supply: %s(%s), signs: valid/total %02d/%02d \n",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_private.total_supply_256)),
- dap_chain_u256tostr(l_token->header_private.total_supply_256),
+ dap_string_append_printf(l_str_out, " 256bit total_supply: %s(%s), signs: valid/total %02d/%02d \n",
+ dap_chain_balance_to_coins(l_token->header_private.total_supply_256),
+ dap_chain_balance_print(l_token->header_private.total_supply_256),
l_token->header_private.signs_valid, l_token->header_private.signs_total);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
@@ -1381,7 +1040,7 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
l_token->header_private.signs_valid, l_token->header_private.signs_total);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
- dap_string_append_printf(l_str_out, "256_t tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+ dap_string_append_printf(l_str_out, "256bit 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;
@@ -1391,37 +1050,36 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
l_token->header_private_decl.flags);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
- dap_string_append_printf(l_str_out, "256_t 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);
+ dap_string_append_printf(l_str_out, "256bit tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
+ l_token->header_private_update.tsd_total_size);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_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);
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
+ l_token->header_private_update.tsd_total_size);
break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: { // 256
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",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_public.total_supply_256)),
- dap_chain_u256tostr(l_token->header_public.total_supply_256),
+ dap_chain_balance_to_coins(l_token->header_public.total_supply_256),
+ dap_chain_balance_print(l_token->header_public.total_supply_256),
l_token->header_public.flags,
- dap_chain_u256tostr(l_token->header_public.premine_supply_256),
+ dap_chain_balance_print(l_token->header_public.premine_supply_256),
l_addr ? l_addr : "-");
DAP_DELETE(l_addr);
- DAP_DELETE(l_balance);
} break;
case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_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);
+ char * l_balance = dap_chain_balance_to_coins(dap_chain_uint256_from_uint128(
+ 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",
- dap_chain_balance_to_coins(l_token->header_public.total_supply),
- dap_chain_balance_print(l_token->header_public.total_supply),
+ l_balance,
+ dap_chain_balance_print(dap_chain_uint256_from_uint128(
+ l_token->header_public.total_supply)),
l_token->header_public.flags,
- dap_chain_balance_print(l_token->header_public.premine_supply),
+ dap_chain_balance_print(dap_chain_uint256_from_uint128(
+ l_token->header_public.premine_supply)),
l_addr ? l_addr : "-");
DAP_DELETE(l_addr);
DAP_DELETE(l_balance);
@@ -1438,7 +1096,6 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
break;
// emission
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
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)) {
@@ -1455,8 +1112,8 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
}
if ( l_token_em->hdr.version == 1 ) { // && l_token_em->hdr.type_256 ) { // 256
dap_string_append_printf(l_str_out, "emission 256: %s(%s) %s, type: %s, version: %d\n",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token_em->hdr.value_256)),
- dap_chain_u256tostr(l_token_em->hdr.value_256),
+ dap_chain_balance_to_coins(l_token_em->hdr.value_256),
+ dap_chain_balance_print(l_token_em->hdr.value_256),
l_token_em->hdr.ticker,
c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
l_token_em->hdr.version);
@@ -1484,21 +1141,12 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
break;
// case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ATOM_OWNER: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
- if ( l_token_em->hdr.version == 1 ) { // && l_token_em->hdr.type_256 ) { // 256
- dap_string_append_printf(l_str_out, " value_start: %s(%s), codename: %s\n",
- dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token_em->data.type_atom_owner.value_start_256)),
- dap_chain_u256tostr(l_token_em->data.type_atom_owner.value_start_256),
- l_token_em->data.type_atom_owner.value_change_algo_codename
- );
- } else {
- dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
- dap_chain_datoshi_to_coins(l_token_em->data.type_atom_owner.value_start),
- l_token_em->data.type_atom_owner.value_start,
- l_token_em->data.type_atom_owner.value_change_algo_codename
- );
- }
+ dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
+ dap_chain_datoshi_to_coins(l_token_em->data.type_atom_owner.value_start),
+ 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_256_SMART_CONTRACT:
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
@@ -1527,20 +1175,7 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
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;
-
- // transaction
- case DAP_CHAIN_DATUM_256_TX:{ // 256
- // 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;
- }
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
- 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;
+ } break;
default:
dap_string_append_printf(l_str_out, "unknown datum type=%d\n", l_datum->header.type_id);
@@ -1613,6 +1248,7 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
+
int l_cmd = CMD_NONE;
if (dap_chain_node_cli_find_option_val(a_argv, 1, 2, "list", NULL)){
l_cmd = CMD_LIST;
@@ -1621,7 +1257,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
if (dap_chain_node_cli_find_option_val(a_argv, 2, 3, "info", NULL))
l_cmd = CMD_TX_INFO;
}
-
// command tx_history
if(l_cmd == CMD_TX_HISTORY) {
bool l_is_all = dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-all", NULL);
@@ -1705,7 +1340,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
else
l_chain_cur = dap_chain_enum(&l_chain_tmp);
while(l_chain_cur) {
-
// only selected net
if(l_net->pub.id.uint64 == l_chain_cur->net_id.uint64) {
// separator between chains
diff --git a/modules/net/dap_chain_node_client.c b/modules/net/dap_chain_node_client.c
index 2f599cd3b0e1b031953bce38261316f8e0f1b2da..819f9ac4e984af9cd1ae9e98eff8901e333a6fdc 100644
--- a/modules/net/dap_chain_node_client.c
+++ b/modules/net/dap_chain_node_client.c
@@ -154,7 +154,6 @@ static void s_stage_status_error_callback(dap_client_t *a_client, void *a_arg)
// check for last attempt
bool l_is_last_attempt = a_arg ? true : false;
if (l_is_last_attempt) {
- dap_chain_node_client_state_t l_prev_state = l_node_client->state;
pthread_mutex_lock(&l_node_client->wait_mutex);
l_node_client->state = NODE_CLIENT_STATE_DISCONNECTED;
#ifndef _WIN32
@@ -165,18 +164,23 @@ static void s_stage_status_error_callback(dap_client_t *a_client, void *a_arg)
pthread_mutex_unlock(&l_node_client->wait_mutex);
l_node_client->esocket_uuid = 0;
- if (l_prev_state >= NODE_CLIENT_STATE_ESTABLISHED && l_node_client->callbacks.disconnected) {
+ if (l_node_client->callbacks.disconnected) {
l_node_client->callbacks.disconnected(l_node_client, l_node_client->callbacks_arg);
- } else if (l_node_client->keep_connection) {
- dap_events_socket_uuid_t *l_uuid = DAP_NEW(dap_events_socket_uuid_t);
- memcpy(l_uuid, &l_node_client->uuid, sizeof(dap_events_socket_uuid_t));
- dap_timerfd_start_on_worker(l_node_client->stream_worker? l_node_client->stream_worker->worker: dap_events_worker_get_auto(),s_timer_update_states*1000,s_timer_update_states_callback, l_uuid);
+ }
+ if (l_node_client->keep_connection) {
+ dap_events_socket_uuid_t *l_uuid = DAP_DUP(&l_node_client->uuid);
+ dap_timerfd_start_on_worker(l_node_client->stream_worker
+ ? l_node_client->stream_worker->worker
+ : dap_events_worker_get_auto(),
+ s_timer_update_states * 1000,
+ s_timer_update_states_callback,
+ l_uuid);
}
return;
}
// TODO make different error codes
if(l_node_client->callbacks.error)
- l_node_client->callbacks.error(l_node_client, EINVAL,l_node_client->callbacks_arg );
+ l_node_client->callbacks.error(l_node_client, EINVAL, l_node_client->callbacks_arg);
}
/**
@@ -228,7 +232,7 @@ static bool s_timer_update_states_callback(void *a_arg)
dap_chain_net_t * l_net = l_node_client->net;
assert(l_net);
// If we do nothing - init sync process
- if (l_ch_chain->state == CHAIN_STATE_IDLE ||l_ch_chain->state == CHAIN_STATE_SYNC_ALL ){
+ if (l_ch_chain->state == CHAIN_STATE_IDLE && dap_chain_net_sync_trylock(l_net, l_me)) {
log_it(L_INFO, "Start synchronization process with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr));
dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
@@ -246,7 +250,8 @@ static bool s_timer_update_states_callback(void *a_arg)
l_me->state = NODE_CLIENT_STATE_DISCONNECTED;
if (l_me->keep_connection) {
log_it(L_INFO, "Reconnecting node client with peer "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_me->remote_node_addr));
- dap_chain_node_client_connect_internal(l_me, "CN"); // isn't always CN here?
+ l_me->state = NODE_CLIENT_STATE_CONNECTING ;
+ dap_client_go_stage(l_me->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
}
DAP_DELETE(l_uuid);
return false;
@@ -405,11 +410,12 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
dap_chain_id_t l_chain_id = {};
dap_chain_cell_id_t l_cell_id = {};
if (a_pkt_type == DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB) {
- if(s_stream_ch_chain_debug_more)
- log_it(L_INFO,"In: Link %s."NODE_ADDR_FP_STR" synced GDB. Going to update chains", l_net->pub.name, NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr ));
- // TODO check if target net state == NET_STATE_SYNC_GDB to not synchronize chains, if it
- l_node_client->cur_chain = l_net->pub.chains;
- l_node_client->cur_cell = l_node_client->cur_chain ? l_node_client->cur_chain->cells : NULL;
+ if (dap_chain_net_get_target_state(l_net) != NET_STATE_SYNC_GDB) {
+ if(s_stream_ch_chain_debug_more)
+ log_it(L_INFO,"In: Link %s."NODE_ADDR_FP_STR" synced GDB. Going to update chains", l_net->pub.name, NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr ));
+ l_node_client->cur_chain = l_net->pub.chains;
+ l_node_client->cur_cell = l_node_client->cur_chain ? l_node_client->cur_chain->cells : NULL;
+ }
} else {
// Check if we over with it before
if ( ! l_node_client->cur_cell ){
@@ -451,8 +457,12 @@ static void s_ch_chain_callback_notify_packet_in(dap_stream_ch_chain_t* a_ch_cha
}else{ // If no - over with sync process
dap_chain_node_addr_t * l_node_addr = dap_chain_net_get_cur_addr(l_net);
log_it(L_INFO, "In: State node %s."NODE_ADDR_FP_STR" is SYNCED",l_net->pub.name, NODE_ADDR_FP_ARGS(l_node_addr) );
+ dap_chain_net_sync_unlock(l_net);
l_node_client->state = NODE_CLIENT_STATE_SYNCED;
- dap_chain_net_set_state(l_net, NET_STATE_ONLINE);
+ if (dap_chain_net_get_target_state(l_net) == NET_STATE_ONLINE)
+ dap_chain_net_set_state(l_net, NET_STATE_ONLINE);
+ else
+ dap_chain_net_state_go_to(l_net, NET_STATE_OFFLINE);
#ifndef _WIN32
pthread_cond_broadcast(&l_node_client->wait_cond);
#else
@@ -662,12 +672,11 @@ static bool dap_chain_node_client_connect_internal(dap_chain_node_client_t *a_no
{
a_node_client->client = dap_client_new(a_node_client->events, s_stage_status_callback,
s_stage_status_error_callback);
- a_node_client->keep_connection = true;
dap_client_set_is_always_reconnect(a_node_client->client, false);
a_node_client->client->_inheritor = a_node_client;
dap_client_set_active_channels_unsafe(a_node_client->client, a_active_channels);
- dap_client_set_auth_cert(a_node_client->client, a_node_client->net->pub.name); // TODO provide the certificate choice
+ dap_client_set_auth_cert(a_node_client->client, a_node_client->net->pub.name);
int hostlen = 128;
char host[hostlen];
@@ -687,8 +696,6 @@ static bool dap_chain_node_client_connect_internal(dap_chain_node_client_t *a_no
}
dap_client_set_uplink_unsafe(a_node_client->client, strdup(host), a_node_client->info->hdr.ext_port);
a_node_client->state = NODE_CLIENT_STATE_CONNECTING ;
- // ref pvt client
- //dap_client_pvt_ref(DAP_CLIENT_PVT(a_node_client->client));
// Handshake & connect
dap_client_go_stage(a_node_client->client, STAGE_STREAM_STREAMING, s_stage_connected_callback);
return true;
@@ -737,6 +744,17 @@ void dap_chain_node_client_close(dap_chain_node_client_t *a_client)
char l_node_addr_str[INET_ADDRSTRLEN] = {};
inet_ntop(AF_INET, &a_client->info->hdr.ext_addr_v4, l_node_addr_str, INET_ADDRSTRLEN);
log_it(L_INFO, "Closing node client to uplink %s:%d", l_node_addr_str, a_client->info->hdr.ext_port);
+ dap_stream_ch_t *l_ch = dap_stream_ch_find_by_uuid_unsafe(a_client->stream_worker, a_client->ch_chain_uuid);
+ if (l_ch) {
+ dap_stream_ch_chain_t *l_ch_chain = DAP_STREAM_CH_CHAIN(l_ch);
+ l_ch_chain->callback_notify_packet_in = NULL;
+ l_ch_chain->callback_notify_packet_out = NULL;
+ }
+ l_ch = dap_stream_ch_find_by_uuid_unsafe(a_client->stream_worker, a_client->ch_chain_net_uuid);
+ if (l_ch) {
+ dap_stream_ch_chain_net_t *l_ch_chain_net = DAP_STREAM_CH_CHAIN_NET(l_ch);
+ l_ch_chain_net->notify_callback = NULL;
+ }
// clean client
dap_client_pvt_t *l_client_pvt = dap_client_pvt_find(a_client->client->pvt_uuid);
if (l_client_pvt) {
diff --git a/modules/net/dap_chain_node_dns_server.c b/modules/net/dap_chain_node_dns_server.c
index 66090c88cf0d36d692757926c689fa92d0c1f0da..3f933f7d7b99c509775186d41163d0f5d083b1fb 100644
--- a/modules/net/dap_chain_node_dns_server.c
+++ b/modules/net/dap_chain_node_dns_server.c
@@ -310,8 +310,8 @@ dap_chain_node_info_t *dap_dns_resolve_hostname(char *str)
if (!l_nodes_count || !l_objs)
return NULL;
dap_chain_node_info_t *l_node_candidate;
- for (int i = 0; i < 5; i++) {
- // 5 tryes for non empty address & port
+ for (int i = 0; i < 50; i++) {
+ // 50 tryes for non empty address & port
size_t l_node_num = rand() % l_nodes_count;
l_node_candidate = (dap_chain_node_info_t *)l_objs[l_node_num].value;
if (l_node_candidate->hdr.ext_addr_v4.s_addr && l_node_candidate->hdr.ext_port)
diff --git a/modules/net/include/dap_chain_net.h b/modules/net/include/dap_chain_net.h
index cb12d6ecd545535deb8fc1b4fd44c91ba9b81fff..142bd80e10711d4bb0f154846e5187a7067a83c5 100644
--- a/modules/net/include/dap_chain_net.h
+++ b/modules/net/include/dap_chain_net.h
@@ -39,7 +39,7 @@ along with any CellFrame SDK based project. If not, see <http://www.gnu.org/lic
#define DAP_CHAIN_NET_NAME_MAX 32
struct dap_chain_node_info;
-struct dap_chain_node_client;
+typedef struct dap_chain_node_client dap_chain_node_client_t;
typedef enum dap_chain_net_state{
NET_STATE_OFFLINE = 0,
@@ -74,6 +74,7 @@ typedef struct dap_chain_net{
// checks
bool token_emission_signs_verify;
+ bool mempool_autoproc;
dap_chain_t * chains; // double-linked list of chains
dap_chain_t * default_chain;
@@ -89,14 +90,14 @@ void dap_chain_net_deinit(void);
void dap_chain_net_load_all();
int dap_chain_net_state_go_to(dap_chain_net_t * a_net, dap_chain_net_state_t a_new_state);
+dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t *a_net);
inline static int dap_chain_net_start(dap_chain_net_t * a_net){ return dap_chain_net_state_go_to(a_net,NET_STATE_ONLINE); }
inline static int dap_chain_net_stop(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_OFFLINE); }
inline static int dap_chain_net_links_establish(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_LINKS_ESTABLISHED); }
-inline static int dap_chain_net_sync_chains(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_CHAINS); }
inline static int dap_chain_net_sync_gdb(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_GDB); }
-inline static int dap_chain_net_sync_all(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_CHAINS); }//NET_STATE_ONLINE
-
+inline static int dap_chain_net_sync_chains(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_CHAINS); }
+inline static int dap_chain_net_sync_all(dap_chain_net_t * a_net) { return dap_chain_net_state_go_to(a_net,NET_STATE_SYNC_CHAINS); }
void dap_chain_net_set_state ( dap_chain_net_t * l_net, dap_chain_net_state_t a_state);
dap_chain_net_state_t dap_chain_net_get_state ( dap_chain_net_t * l_net);
@@ -117,6 +118,8 @@ void dap_chain_net_proc_mempool (dap_chain_net_t * a_net);
void dap_chain_net_set_flag_sync_from_zero(dap_chain_net_t * a_net, bool a_flag_sync_from_zero);
bool dap_chain_net_get_flag_sync_from_zero( dap_chain_net_t * a_net);
+bool dap_chain_net_sync_trylock(dap_chain_net_t *a_net, dap_chain_node_client_t *a_client);
+void dap_chain_net_sync_unlock(dap_chain_net_t *a_net);
dap_chain_net_t * dap_chain_net_by_name( const char * a_name);
dap_chain_net_t * dap_chain_net_by_id( dap_chain_net_id_t a_id);
@@ -172,7 +175,7 @@ dap_chain_net_t **dap_chain_net_list(uint16_t *a_size);
bool dap_chain_net_get_add_gdb_group(dap_chain_net_t *a_net, dap_chain_node_addr_t a_node_addr);
int dap_chain_net_verify_datum_for_add(dap_chain_net_t *a_net, dap_chain_datum_t * a_datum );
-void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_datum, const char *a_hash_out_type);
+void dap_chain_net_dump_datum(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, const char *a_hash_out_type);
void dap_chain_net_set_srv_callback_notify(dap_global_db_obj_callback_notify_t a_callback);
void dap_chain_net_sync_gdb_broadcast(void *a_arg, const char a_op_code, const char *a_group,
const char *a_key, const void *a_value, const size_t a_value_len);
diff --git a/modules/net/include/dap_chain_node.h b/modules/net/include/dap_chain_node.h
index 703175de5068982408b12d69a41216642fd1894e..447527b6a5835d3e632aca1c9917112219cec923 100644
--- a/modules/net/include/dap_chain_node.h
+++ b/modules/net/include/dap_chain_node.h
@@ -122,14 +122,14 @@ size_t dap_chain_node_info_get_size(dap_chain_node_info_t *node_info);
//dap_chain_node_info_t* dap_chain_node_info_deserialize(uint8_t *node_info_str, size_t size);
/**
- * Generate node addr by net id
+ * Generate node addr by shard id
*/
dap_chain_node_addr_t* dap_chain_node_gen_addr(dap_chain_net_id_t a_net_id);
/**
* Check the validity of the node address by shard id
*/
-bool dap_chain_node_check_addr(dap_chain_net_t * l_net, dap_chain_node_addr_t *a_addr);
+bool dap_chain_node_check_addr(dap_chain_net_t * l_net,dap_chain_node_addr_t *addr);
dap_chain_node_addr_t * dap_chain_node_alias_find(dap_chain_net_t * l_net,const char *alias);
bool dap_chain_node_alias_register(dap_chain_net_t *a_net, const char *a_alias, dap_chain_node_addr_t *a_addr);
@@ -144,7 +144,7 @@ inline static char* dap_chain_node_addr_to_hash_str(dap_chain_node_addr_t *addre
return a_key;
}
-int dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_node_role_t a_role, dap_chain_datum_t *a_datum);
+int dap_chain_node_mempool_process(dap_chain_t *a_chain, dap_chain_datum_t *a_datum);
bool dap_chain_node_mempool_autoproc_init();
void dap_chain_node_mempool_autoproc_deinit();
void dap_chain_node_mempool_autoproc_notify(void *a_arg, const char a_op_code, const char *a_group,
diff --git a/modules/net/include/dap_chain_node_cli_cmd.h b/modules/net/include/dap_chain_node_cli_cmd.h
index 4ac0d989e399f6214028df72a42f0043cdd13e4e..ea22439219fab6b73ea5258ce6e5a7bd426c6a4e 100644
--- a/modules/net/include/dap_chain_node_cli_cmd.h
+++ b/modules/net/include/dap_chain_node_cli_cmd.h
@@ -117,7 +117,7 @@ int com_tx_cond_create(int argc, char ** argv, char **str_reply);
*
* Verifing transaction
*/
-int com_tx_verify(int argc, char ** argv, char **str_reply);
+int com_tx_verify(int a_argc, char ** a_argv, char **a_str_reply);
/**
* tx_history command
diff --git a/modules/net/include/dap_chain_node_client.h b/modules/net/include/dap_chain_node_client.h
index 92a7ba56d3479fbf01a31fe3d3ea3f0b78142ec2..21902259e9901466c29bc498cdd74e7e562cdbeb 100644
--- a/modules/net/include/dap_chain_node_client.h
+++ b/modules/net/include/dap_chain_node_client.h
@@ -114,7 +114,7 @@ typedef struct dap_chain_node_client {
bool keep_connection;
- bool is_reconnecting;
+ bool is_connected;
// callbacks
dap_chain_node_client_callbacks_t callbacks;
void * callbacks_arg;
diff --git a/modules/net/srv/CMakeLists.txt b/modules/net/srv/CMakeLists.txt
index 399b0a433767971f7af42388381ad7e80c303885..505a2deb8bc6634dccf8969c98e201485493d885 100644
--- a/modules/net/srv/CMakeLists.txt
+++ b/modules/net/srv/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv)
file(GLOB DAP_CHAIN_NET_SRV_SRCS *.c libmaxminddb/*.c)
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 5206e305e18b7e83014b1641840bda9553b6ac05..19a6ea5f7acf57ebe7ac391e1ef16434092de983 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -111,13 +111,13 @@ int dap_chain_net_srv_init()
" -price_unit <Price Unit> -price_token <Token ticker> [-node_addr <Node Address>] [-tx_cond <TX Cond Hash>]\n"
" [-expires <Unix time when expires>] [-cert <cert name to sign order>]\n"
" [{-ext <Extension with params> | -region <Region name> -continent <Continent name>}]\n"
-
+#ifdef DAP_MODULES_DYNAMIC
"\tOrder create\n"
"net_srv -net <chain net name> order static [save | delete]\n"
"\tStatic nodelist create/delete\n"
"net_srv -net <chain net name> order recheck\n"
"\tCheck the availability of orders\n"
-
+#endif
);
s_load_all();
@@ -303,7 +303,7 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
if(l_ext) {
l_order->ext_size = strlen(l_ext) + 1;
l_order = DAP_REALLOC(l_order, sizeof(dap_chain_net_srv_order_t) + l_order->ext_size);
- strncpy((char *)l_order->ext, l_ext, l_order->ext_size);
+ strncpy((char *)l_order->ext_n_sign, l_ext, l_order->ext_size);
}
else
dap_chain_net_srv_order_set_continent_region(&l_order, l_continent_num, l_region_str);
@@ -365,7 +365,8 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
dap_chain_net_srv_order_direction_t l_direction = SERV_DIR_UNDEFINED;
dap_chain_net_srv_uid_t l_srv_uid={{0}};
- uint64_t l_price_min=0, l_price_max =0 ;
+ uint256_t l_price_min = {};
+ uint256_t l_price_max = {};
dap_chain_net_srv_price_unit_uid_t l_price_unit={{0}};
if ( l_direction_str ){
@@ -379,10 +380,10 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
l_srv_uid.uint64 = (uint64_t) atoll( l_srv_uid_str);
if ( l_price_min_str )
- l_price_min = (uint64_t) atoll ( l_price_min_str );
+ l_price_min = dap_chain_balance_scan(l_price_min_str);
if ( l_price_max_str )
- l_price_max = (uint64_t) atoll ( l_price_max_str );
+ l_price_max = dap_chain_balance_scan(l_price_max_str);
if ( l_price_unit_str)
l_price_unit.uint32 = (uint32_t) atol ( l_price_unit_str );
@@ -423,7 +424,8 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
dap_chain_net_srv_order_t * l_orders = NULL;
size_t l_orders_num =0;
dap_chain_net_srv_uid_t l_srv_uid={{0}};
- uint64_t l_price_min=0, l_price_max =0 ;
+ uint256_t l_price_min = {};
+ uint256_t l_price_max = {};
dap_chain_net_srv_price_unit_uid_t l_price_unit={{0}};
dap_chain_net_srv_order_direction_t l_direction = SERV_DIR_UNDEFINED;
@@ -475,7 +477,7 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
dap_chain_node_addr_t l_node_addr={0};
dap_chain_hash_fast_t l_tx_cond_hash={{0}};
dap_chain_time_t l_expires=0; // TS when the service expires
- uint64_t l_price=0;
+ uint256_t l_price = {};
char l_price_token[DAP_CHAIN_TICKER_SIZE_MAX]={0};
dap_chain_net_srv_price_unit_uid_t l_price_unit={{0}};
dap_chain_net_srv_order_direction_t l_direction = SERV_DIR_UNDEFINED;
@@ -503,7 +505,7 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
}
if (l_tx_cond_hash_str)
dap_chain_hash_fast_from_str (l_tx_cond_hash_str, &l_tx_cond_hash);
- l_price = (uint64_t) atoll ( l_price_str );
+ l_price = dap_chain_balance_scan(l_price_str);
l_price_unit.uint32 = (uint32_t) atol ( l_price_unit_str );
strncpy(l_price_token, l_price_token_str, DAP_CHAIN_TICKER_SIZE_MAX - 1);
size_t l_ext_len = l_ext? strlen(l_ext) + 1 : 0;
@@ -536,11 +538,16 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
}
#ifdef DAP_MODULES_DYNAMIC
else if( dap_strcmp( l_order_str, "recheck" ) == 0 ){
- //int dap_chain_net_srv_vpn_cdb_server_list_check_orders(dap_chain_net_t *a_net);
int (*dap_chain_net_srv_vpn_cdb_server_list_check_orders)(dap_chain_net_t *a_net);
dap_chain_net_srv_vpn_cdb_server_list_check_orders = dap_modules_dynamic_get_cdb_func("dap_chain_net_srv_vpn_cdb_server_list_check_orders");
int l_init_res = dap_chain_net_srv_vpn_cdb_server_list_check_orders ? dap_chain_net_srv_vpn_cdb_server_list_check_orders(l_net) : -5;
- ret = (l_init_res > 0) ? 0 : -10;
+ if (l_init_res >= 0) {
+ dap_string_append_printf(l_string_ret, "Orders recheck started\n");
+ ret = 0;
+ } else {
+ dap_string_append_printf(l_string_ret, "Orders recheck not started, code %d\n", l_init_res);
+ ret = -10;
+ }
}else if( dap_strcmp( l_order_str, "static" ) == 0 ){
// find the subcommand directly after the 'order' command
@@ -584,7 +591,10 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
}
}
#endif
- else {
+ else if (l_order_str) {
+ dap_string_append_printf(l_string_ret, "Unrecognized subcommand '%s'", l_order_str);
+ ret = -14;
+ } else {
dap_string_append_printf(l_string_ret, "Command 'net_srv' requires subcommand 'order'");
ret = -3;
}
@@ -836,7 +846,7 @@ dap_chain_datum_tx_receipt_t * dap_chain_net_srv_issue_receipt(dap_chain_net_srv
)
{
dap_chain_datum_tx_receipt_t * l_receipt = dap_chain_datum_tx_receipt_create(
- a_srv->uid, a_price->units_uid, a_price->units, a_price->value_datoshi, a_ext, a_ext_size);
+ a_srv->uid, a_price->units_uid, a_price->units, dap_chain_uint256_from(a_price->value_datoshi), a_ext, a_ext_size);
size_t l_receipt_size = l_receipt->size; // nested receipt plus 8 bits for type
// Sign with our wallet
diff --git a/modules/net/srv/dap_chain_net_srv_order.c b/modules/net/srv/dap_chain_net_srv_order.c
index 56cdef9d0ebdbfaf3be0e9342f8573e6e9dfae25..361a275c2eca7c8912d63c76e93a16bdc8630582 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -83,11 +83,13 @@ size_t dap_chain_net_srv_order_get_size(dap_chain_net_srv_order_t *a_order)
if (!a_order)
return 0;
size_t l_sign_size = 0;
+ size_t l_header_size = sizeof(dap_chain_net_srv_order_old_t);
if (a_order->version > 1) {
- dap_sign_t *l_sign = (dap_sign_t *)&a_order->ext[a_order->ext_size];
+ dap_sign_t *l_sign = (dap_sign_t *)&a_order->ext_n_sign[a_order->ext_size];
l_sign_size = dap_sign_get_size(l_sign);
+ l_header_size = sizeof(dap_chain_net_srv_order_t);
}
- return sizeof(dap_chain_net_srv_order_t) + a_order->ext_size + l_sign_size;
+ return l_header_size + a_order->ext_size + l_sign_size;
}
/**
@@ -110,15 +112,15 @@ bool dap_chain_net_srv_order_set_continent_region(dap_chain_net_srv_order_t **a_
l_ext_size += strlen(l_region_prev) + 1;
l_order = DAP_REALLOC(l_order, sizeof(dap_chain_net_srv_order_t) + l_ext_size);
- l_order->ext[0] =0x52;
+ l_order->ext_n_sign[0] =0x52;
if(a_continent_num > 0)
- memcpy(l_order->ext + 1, &a_continent_num, sizeof(uint8_t));
+ memcpy(l_order->ext_n_sign + 1, &a_continent_num, sizeof(uint8_t));
else
- memcpy(l_order->ext + 1, &l_continent_num_prev, sizeof(uint8_t));
+ memcpy(l_order->ext_n_sign + 1, &l_continent_num_prev, sizeof(uint8_t));
if(a_region)
- memcpy(l_order->ext + 1 + sizeof(uint8_t), a_region, strlen(a_region) + 1);
+ memcpy(l_order->ext_n_sign + 1 + sizeof(uint8_t), a_region, strlen(a_region) + 1);
else if(l_region_prev)
- memcpy(l_order->ext + 1 + sizeof(uint8_t), l_region_prev, strlen(l_region_prev) + 1);
+ memcpy(l_order->ext_n_sign + 1 + sizeof(uint8_t), l_region_prev, strlen(l_region_prev) + 1);
//dap_sprintf(l_order->ext, "\52%d-%s", a_continent_num, a_region);
l_order->ext_size = l_ext_size;
*a_order = l_order;
@@ -133,11 +135,11 @@ bool dap_chain_net_srv_order_set_continent_region(dap_chain_net_srv_order_t **a_
*/
bool dap_chain_net_srv_order_get_continent_region(dap_chain_net_srv_order_t *a_order_static, uint8_t *a_continent_num, char **a_region)
{
- if(!a_order_static || !a_order_static->ext_size || a_order_static->ext[0]!=0x52)
+ if(!a_order_static || !a_order_static->ext_size || a_order_static->ext_n_sign[0]!=0x52)
return false;
if(a_continent_num) {
- if((uint8_t)a_order_static->ext[1]!=0xff)
- memcpy(a_continent_num, a_order_static->ext + 1, sizeof(uint8_t));
+ if((uint8_t)a_order_static->ext_n_sign[1]!=0xff)
+ memcpy(a_continent_num, a_order_static->ext_n_sign + 1, sizeof(uint8_t));
else
a_continent_num = 0;
}
@@ -145,7 +147,7 @@ bool dap_chain_net_srv_order_get_continent_region(dap_chain_net_srv_order_t *a_o
size_t l_size = a_order_static->ext_size - sizeof(uint8_t) - 1;
if(l_size > 0) {
*a_region = DAP_NEW_SIZE(char, l_size);
- memcpy(*a_region, a_order_static->ext + 1 + sizeof(uint8_t), l_size);
+ memcpy(*a_region, a_order_static->ext_n_sign + 1 + sizeof(uint8_t), l_size);
}
else
*a_region = NULL;
@@ -224,7 +226,7 @@ char * dap_chain_net_srv_order_create(
dap_chain_net_srv_uid_t a_srv_uid, // Service UID
dap_chain_node_addr_t a_node_addr, // Node address that servs the order (if present)
dap_chain_hash_fast_t a_tx_cond_hash, // Hash index of conditioned transaction attached with order
- uint64_t a_price, // service price in datoshi, for SERV_CLASS_ONCE ONCE for the whole service, for SERV_CLASS_PERMANENT for one unit.
+ uint256_t a_price, // service price in datoshi, for SERV_CLASS_ONCE ONCE for the whole service, for SERV_CLASS_PERMANENT for one unit.
dap_chain_net_srv_price_unit_uid_t a_price_unit, // Unit of service (seconds, megabytes, etc.) Only for SERV_CLASS_PERMANENT
const char a_price_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
dap_chain_time_t a_expires, // TS when the service expires
@@ -240,7 +242,7 @@ char * dap_chain_net_srv_order_create(
dap_chain_net_srv_order_t *l_order;
if (a_ext_size) {
l_order = (dap_chain_net_srv_order_t *)DAP_NEW_Z_SIZE(void, sizeof(dap_chain_net_srv_order_t) + a_ext_size);
- memcpy(l_order->ext, a_ext, a_ext_size);
+ memcpy(l_order->ext_n_sign, a_ext, a_ext_size);
l_order->ext_size = a_ext_size;
}
else {
@@ -249,7 +251,7 @@ char * dap_chain_net_srv_order_create(
}
dap_chain_hash_fast_t l_order_hash;
- l_order->version = a_key ? 2 : 1;
+ l_order->version = 2;
l_order->srv_uid = a_srv_uid;
l_order->direction = a_direction;
l_order->ts_created = (dap_chain_time_t) time(NULL);
@@ -271,7 +273,7 @@ char * dap_chain_net_srv_order_create(
}
size_t l_sign_size = dap_sign_get_size(l_sign); // sign data
l_order = DAP_REALLOC(l_order, sizeof(dap_chain_net_srv_order_t) + l_order->ext_size + l_sign_size);
- memcpy(&l_order->ext[l_order->ext_size], l_sign, l_sign_size);
+ memcpy(&l_order->ext_n_sign[l_order->ext_size], l_sign, l_sign_size);
DAP_DELETE(l_sign);
}
size_t l_order_size = dap_chain_net_srv_order_get_size(l_order);
@@ -353,7 +355,7 @@ dap_chain_net_srv_order_t * dap_chain_net_srv_order_find_by_hash_str(dap_chain_n
int dap_chain_net_srv_order_find_all_by(dap_chain_net_t * a_net,const dap_chain_net_srv_order_direction_t a_direction,
const dap_chain_net_srv_uid_t a_srv_uid,
const dap_chain_net_srv_price_unit_uid_t a_price_unit,const char a_price_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- const uint64_t a_price_min, const uint64_t a_price_max,
+ const uint256_t a_price_min, const uint256_t a_price_max,
dap_chain_net_srv_order_t ** a_output_orders, size_t * a_output_orders_count)
{
if ( a_net && a_output_orders && a_output_orders_count ){
@@ -368,7 +370,7 @@ lb_order_pass:
l_order_passed_index = 0;
l_orders_size = 0;
for (size_t i=0; i< l_orders_count; i++){
- dap_chain_net_srv_order_t * l_order = (dap_chain_net_srv_order_t *) l_orders[i].value;
+ dap_chain_net_srv_order_t * l_order = (dap_chain_net_srv_order_t *)l_orders[i].value;
if (l_order->version > 2 || l_order->direction > SERV_DIR_SELL ||
dap_chain_net_srv_order_get_size(l_order) != l_orders[i].value_len) {
continue; // order is corrupted
@@ -387,12 +389,10 @@ lb_order_pass:
if ( a_price_unit.uint32 != l_order->price_unit.uint32 )
continue;
// Check price minimum
- if ( a_price_min )
- if ( l_order->price < a_price_min )
+ if (!IS_ZERO_256(a_price_min) && compare256(l_order->price, a_price_min) == -1)
continue;
// Check price maximum
- if ( a_price_max )
- if ( l_order->price > a_price_max )
+ if (!IS_ZERO_256(a_price_max) && compare256(l_order->price, a_price_max) == 1)
continue;
// Check ticker
if ( a_price_ticker )
@@ -472,7 +472,7 @@ void dap_chain_net_srv_order_dump_to_string(dap_chain_net_srv_order_t *a_order,d
}
dap_string_append_printf(a_str_out, " srv_uid: 0x%016"DAP_UINT64_FORMAT_X"\n", a_order->srv_uid.uint64 );
- dap_string_append_printf(a_str_out, " price: %.7Lf (%"DAP_UINT64_FORMAT_U")\n", dap_chain_datoshi_to_coins(a_order->price) , a_order->price);
+ dap_string_append_printf(a_str_out, " price: %s (%s)\n", dap_chain_balance_to_coins(a_order->price), dap_chain_balance_print(a_order->price));
if( a_order->price_unit.uint32 )
dap_string_append_printf(a_str_out, " price_unit: %s\n", dap_chain_net_srv_price_unit_uid_to_str(a_order->price_unit) );
if ( a_order->node_addr.uint64)
@@ -494,7 +494,7 @@ void dap_chain_net_srv_order_dump_to_string(dap_chain_net_srv_order_t *a_order,d
//dap_chain_hash_fast_to_str(&a_order->tx_cond_hash,l_hash_str, sizeof(l_hash_str)-1);
dap_string_append_printf(a_str_out, " tx_cond_hash: %s\n", l_hash_str );
char *l_ext_out = a_order->ext_size ? DAP_NEW_Z_SIZE(char, a_order->ext_size * 2 + 1) : NULL;
- dap_bin2hex(l_ext_out, a_order->ext, a_order->ext_size);
+ dap_bin2hex(l_ext_out, a_order->ext_n_sign, a_order->ext_size);
if(l_ext_out)
dap_string_append_printf(a_str_out, " ext: 0x%s\n", l_ext_out);
else
@@ -531,7 +531,7 @@ static void s_srv_order_callback_notify(void *a_arg, const char a_op_code, const
if (l_order->version != 2) {
dap_chain_global_db_gr_del(dap_strdup(a_key), a_group);
} else {
- dap_sign_t *l_sign = (dap_sign_t *)&l_order->ext[l_order->ext_size];
+ dap_sign_t *l_sign = (dap_sign_t *)&l_order->ext_n_sign[l_order->ext_size];
if (!dap_sign_verify_size(l_sign, a_value_len) ||
dap_sign_verify(l_sign, l_order, sizeof(dap_chain_net_srv_order_t) + l_order->ext_size) != 1) {
dap_chain_global_db_gr_del(dap_strdup(a_key), a_group);
@@ -546,9 +546,8 @@ static void s_srv_order_callback_notify(void *a_arg, const char a_op_code, const
}
dap_chain_addr_t l_addr = {};
dap_chain_addr_fill(&l_addr, l_sign->header.type, &l_pkey_hash, l_net->pub.id);
- // uint128_t l_balance = dap_chain_ledger_calc_balance(l_net->pub.ledger, &l_addr, l_order->price_ticker);
- uint256_t l_balance = dap_chain_ledger_calc_balance(l_net->pub.ledger, &l_addr, l_order->price_ticker);
- uint64_t l_solvency = dap_chain_uint256_to(l_balance);
+ uint128_t l_balance = dap_chain_ledger_calc_balance(l_net->pub.ledger, &l_addr, l_order->price_ticker);
+ uint64_t l_solvency = dap_chain_uint128_to(l_balance);
if (l_solvency < l_order->price && !dap_chain_net_srv_stake_key_delegated(&l_addr)) {
dap_chain_global_db_gr_del(dap_strdup(a_key), a_group);
}*/
diff --git a/modules/net/srv/include/dap_chain_net_srv_common.h b/modules/net/srv/include/dap_chain_net_srv_common.h
index a6ab4bf0838149ef687ecf8428623b05e75f979a..9c56f4dc38f75c29522b61b74d8ac808c37f54a5 100755
--- a/modules/net/srv/include/dap_chain_net_srv_common.h
+++ b/modules/net/srv/include/dap_chain_net_srv_common.h
@@ -37,11 +37,12 @@
//Service direction
-typedef enum dap_chain_net_srv_order_direction{
+enum dap_chain_net_srv_order_direction{
SERV_DIR_BUY = 1,
SERV_DIR_SELL = 2,
SERV_DIR_UNDEFINED = 0
-} dap_chain_net_srv_order_direction_t;
+};
+typedef byte_t dap_chain_net_srv_order_direction_t;
typedef struct dap_chain_net_srv_abstract
diff --git a/modules/net/srv/include/dap_chain_net_srv_order.h b/modules/net/srv/include/dap_chain_net_srv_order.h
index 809305a7cfe03d28ee240ca2f710f6b12ec51e2e..5a4d496e0071aa9726dbb2eab5e41b00f13a52a5 100644
--- a/modules/net/srv/include/dap_chain_net_srv_order.h
+++ b/modules/net/srv/include/dap_chain_net_srv_order.h
@@ -29,12 +29,12 @@ along with any CellFrame SDK based project. If not, see <http://www.gnu.org/lic
#include "dap_chain_common.h"
#include "dap_chain_net_srv_common.h"
-typedef struct dap_chain_net_srv_order
+typedef struct dap_chain_net_srv_order_old
{
uint16_t version;
dap_chain_net_srv_uid_t srv_uid; // Service UID
byte_t padding; // some padding
- dap_chain_net_srv_order_direction_t direction:8; // Order direction - SELL or PURCHASE
+ dap_chain_net_srv_order_direction_t direction; // Order direction - SELL or PURCHASE
dap_chain_node_addr_t node_addr; // Node address that servs the order (if present)
dap_chain_hash_fast_t tx_cond_hash; // Hash index of conditioned transaction attached with order
dap_chain_net_srv_price_unit_uid_t price_unit; // Unit of service (seconds, megabytes, etc.) Only for SERV_CLASS_PERMANENT
@@ -46,6 +46,24 @@ typedef struct dap_chain_net_srv_order
//char region[32];
uint32_t ext_size;
uint8_t ext[];
+} DAP_ALIGN_PACKED dap_chain_net_srv_order_old_t;
+
+typedef struct dap_chain_net_srv_order
+{
+ uint16_t version;
+ dap_chain_net_srv_uid_t srv_uid; // Service UID
+ byte_t padding; // some padding
+ dap_chain_net_srv_order_direction_t direction; // Order direction - SELL or PURCHASE
+ dap_chain_node_addr_t node_addr; // Node address that servs the order (if present)
+ dap_chain_hash_fast_t tx_cond_hash; // Hash index of conditioned transaction attached with order
+ dap_chain_net_srv_price_unit_uid_t price_unit; // Unit of service (seconds, megabytes, etc.) Only for SERV_CLASS_PERMANENT
+ dap_chain_time_t ts_created;
+ dap_chain_time_t ts_expires;
+ uint256_t price; // service price in datoshi, for SERV_CLASS_ONCE ONCE for the whole service, for SERV_CLASS_PERMANENT for one unit.
+ char price_ticker[DAP_CHAIN_TICKER_SIZE_MAX]; // Token ticker to pay for service
+ byte_t free_space[128]; // for future changes
+ uint32_t ext_size;
+ uint8_t ext_n_sign[];
} DAP_ALIGN_PACKED dap_chain_net_srv_order_t;
// Init/deinit should be call only if private
@@ -74,8 +92,8 @@ DAP_STATIC_INLINE dap_chain_net_srv_order_t * dap_chain_net_srv_order_find_by_ha
return NULL;
}
-int dap_chain_net_srv_order_find_all_by(dap_chain_net_t * a_net,const dap_chain_net_srv_order_direction_t a_direction, const dap_chain_net_srv_uid_t a_srv_uid,
- const dap_chain_net_srv_price_unit_uid_t a_price_unit, const char a_price_ticker[DAP_CHAIN_TICKER_SIZE_MAX],const uint64_t a_price_min, const uint64_t a_price_max,
+int dap_chain_net_srv_order_find_all_by(dap_chain_net_t * a_net, const dap_chain_net_srv_order_direction_t a_direction, const dap_chain_net_srv_uid_t a_srv_uid,
+ const dap_chain_net_srv_price_unit_uid_t a_price_unit, const char a_price_ticker[DAP_CHAIN_TICKER_SIZE_MAX], const uint256_t a_price_min, const uint256_t a_price_max,
dap_chain_net_srv_order_t ** a_output_orders, size_t * a_output_orders_count);
int dap_chain_net_srv_order_delete_by_hash_str( dap_chain_net_t * a_net,const char * a_hash_str );
@@ -97,7 +115,7 @@ char *dap_chain_net_srv_order_create(dap_chain_net_t * a_net,
dap_chain_net_srv_uid_t a_srv_uid, // Service UID
dap_chain_node_addr_t a_node_addr, // Node address that servs the order (if present)
dap_chain_hash_fast_t a_tx_cond_hash, // Hash index of conditioned transaction attached with order
- uint64_t a_price, // service price in datoshi, for SERV_CLASS_ONCE ONCE for the whole service, for SERV_CLASS_PERMANENT for one unit.
+ uint256_t a_price, // service price in datoshi, for SERV_CLASS_ONCE ONCE for the whole service, for SERV_CLASS_PERMANENT for one unit.
dap_chain_net_srv_price_unit_uid_t a_price_unit, // Unit of service (seconds, megabytes, etc.) Only for SERV_CLASS_PERMANENT
const char a_price_ticker[],
dap_chain_time_t a_expires, // TS when the service expires
diff --git a/modules/service/app-db/CMakeLists.txt b/modules/service/app-db/CMakeLists.txt
index 66ca6ade4273ae9e2e34d8d15795c869529401dc..b4126024c981d5b9f6626c906d6edac2744e9b5f 100644
--- a/modules/service/app-db/CMakeLists.txt
+++ b/modules/service/app-db/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_app_db)
file(GLOB DAP_CHAIN_NET_SRV_APP_DB_SRCS *.c)
diff --git a/modules/service/app/CMakeLists.txt b/modules/service/app/CMakeLists.txt
index 210374c2f42c6e5a616714fabdd788da5235e848..6b36635629648f54fd13a8fd30add481f16115ff 100644
--- a/modules/service/app/CMakeLists.txt
+++ b/modules/service/app/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_app)
file(GLOB DAP_CHAIN_NET_SRV_APP_SRCS *.c)
diff --git a/modules/service/datum/CMakeLists.txt b/modules/service/datum/CMakeLists.txt
index 62ad4a0ba48cf1603be5e5a9d22959f881683498..6e00de0ce3e876786a73a34a57d6f97a93271783 100644
--- a/modules/service/datum/CMakeLists.txt
+++ b/modules/service/datum/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_datum)
file(GLOB DAP_CHAIN_NET_SRV_DATUM_SRCS *.c)
diff --git a/modules/service/mining-pool/CMakeLists.txt b/modules/service/mining-pool/CMakeLists.txt
index 7db0c520a52b763772d313a21ec2d1a0ff55540e..e11093c3358acf2c27226ea4630ac0baba9d4aaa 100644
--- a/modules/service/mining-pool/CMakeLists.txt
+++ b/modules/service/mining-pool/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_datum_pool)
file(GLOB DAP_CHAIN_NET_SRV_DATUM_POOL_SRCS *.c)
diff --git a/modules/service/stake/CMakeLists.txt b/modules/service/stake/CMakeLists.txt
index 99474583910ad884edbd0326202522816a11ced1..c5153d762654201ccba0c6a30a8c535c3e1e9151 100644
--- a/modules/service/stake/CMakeLists.txt
+++ b/modules/service/stake/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_stake)
file(GLOB DAP_SRV_STAKE_SRCS *.c)
diff --git a/modules/service/stake/dap_chain_net_srv_stake.c b/modules/service/stake/dap_chain_net_srv_stake.c
index 89f9534e1988fc9fc4ef7b7df5f772270b76a6c7..856f9c9a82a2bd0dea9af91e83c5cb1935a9fb6f 100644
--- a/modules/service/stake/dap_chain_net_srv_stake.c
+++ b/modules/service/stake/dap_chain_net_srv_stake.c
@@ -282,7 +282,7 @@ bool dap_chain_net_srv_stake_validator(dap_chain_addr_t *a_addr, dap_chain_datum
dap_sign_get_pkey_hash(l_sign, &l_pkey_hash);
dap_chain_addr_t l_owner_addr = {};
dap_chain_addr_fill(&l_owner_addr, l_sign->header.type, &l_pkey_hash, a_addr->net_id);
- uint64_t l_outs_sum = 0, l_fee_sum = 0;
+ uint256_t l_outs_sum = {}, l_fee_sum = {};
dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
uint32_t l_out_idx_tmp = 0; // current index of 'out' item
for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_out_idx_tmp++) {
@@ -290,22 +290,31 @@ bool dap_chain_net_srv_stake_validator(dap_chain_addr_t *a_addr, dap_chain_datum
if (l_type == TX_ITEM_TYPE_OUT) {
dap_chain_tx_out_t *l_out = (dap_chain_tx_out_t *)l_list_tmp->data;
if (!memcmp(&l_stake->addr_fee, &l_out->addr, sizeof(dap_chain_addr_t))) {
- l_fee_sum += l_out->header.value;
+ SUM_256_256(l_fee_sum, dap_chain_uint256_from(l_out->header.value), &l_fee_sum);
} else if (memcmp(&l_owner_addr, &l_out->addr, sizeof(dap_chain_addr_t))) {
- l_outs_sum += l_out->header.value;
+ SUM_256_256(l_outs_sum, dap_chain_uint256_from(l_out->header.value), &l_outs_sum);
+ }
+ }
+ if (l_type == TX_ITEM_TYPE_OUT_256) {
+ dap_chain_256_tx_out_t *l_out = (dap_chain_256_tx_out_t *)l_list_tmp->data;
+ if (!memcmp(&l_stake->addr_fee, &l_out->addr, sizeof(dap_chain_addr_t))) {
+ SUM_256_256(l_fee_sum, l_out->header.value, &l_fee_sum);
+ } else if (memcmp(&l_owner_addr, &l_out->addr, sizeof(dap_chain_addr_t))) {
+ SUM_256_256(l_outs_sum, l_out->header.value, &l_outs_sum);
}
}
if (l_type == TX_ITEM_TYPE_OUT_EXT) {
dap_chain_tx_out_ext_t *l_out_ext = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
if (!memcmp(&l_stake->addr_fee, &l_out_ext->addr, sizeof(dap_chain_addr_t))) {
- l_fee_sum += l_out_ext->header.value;
+ SUM_256_256(l_fee_sum, l_out_ext->header.value, &l_fee_sum);
} else if (memcmp(&l_owner_addr, &l_out_ext->addr, sizeof(dap_chain_addr_t))) {
- l_outs_sum += l_out_ext->header.value;
+ SUM_256_256(l_outs_sum, l_out_ext->header.value, &l_outs_sum);
}
}
}
dap_list_free(l_list_out_items);
- if (l_fee_sum < l_outs_sum * l_stake->fee_value / 100.0) {
+ uint256_t l_fee = MULT_256_FLOAT(l_outs_sum, l_stake->fee_value / 100.0);
+ if (compare256(l_fee_sum, l_fee) == -1) {
return false;
}
return true;
@@ -328,7 +337,7 @@ static dap_chain_datum_tx_t *s_stake_tx_create(dap_chain_net_srv_stake_item_t *a
return NULL;
}
dap_enc_key_t *l_owner_key = dap_chain_wallet_get_key(a_wallet, 0);
- uint64_t l_value_sell = 0; // how many coins to transfer
+ uint256_t l_value_sell = {}; // how many coins to transfer
// list of transaction with 'out' items to sell
dap_list_t *l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(l_ledger, a_stake->token, l_owner_addr, a_stake->value, &l_value_sell);
if(!l_list_used_out) {
@@ -339,9 +348,9 @@ static dap_chain_datum_tx_t *s_stake_tx_create(dap_chain_net_srv_stake_item_t *a
}
// add 'in' items to sell
- uint64_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
+ uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
dap_list_free_full(l_list_used_out, free);
- if (l_value_to_items != l_value_sell) {
+ if (!EQUAL_256(l_value_to_items,l_value_sell)) {
dap_chain_datum_tx_delete(l_tx);
DAP_DELETE(l_owner_addr);
log_it(L_ERROR, "Can't compose the transaction input");
@@ -363,8 +372,9 @@ static dap_chain_datum_tx_t *s_stake_tx_create(dap_chain_net_srv_stake_item_t *a
dap_chain_datum_tx_add_item(&l_tx, (const uint8_t *)l_tx_out);
DAP_DELETE(l_tx_out);
// coin back
- uint64_t l_value_back = l_value_sell - a_stake->value;
- if (l_value_back) {
+ uint256_t l_value_back = {};
+ SUBTRACT_256_256(l_value_sell, a_stake->value, &l_value_back);
+ if (!IS_ZERO_256(l_value_back)) {
if (dap_chain_datum_tx_add_out_item(&l_tx, l_owner_addr, l_value_back) != 1) {
dap_chain_datum_tx_delete(l_tx);
DAP_DELETE(l_owner_addr);
@@ -431,7 +441,7 @@ static dap_chain_datum_tx_t *s_stake_tx_approve(dap_chain_net_srv_stake_item_t *
log_it(L_WARNING, "Requested conditional transaction is already used out");
return NULL;
}
- assert(l_tx_out_cond->header.value == a_stake->value);
+ assert(EQUAL_256(l_tx_out_cond->header.value, a_stake->value));
dap_chain_datum_tx_add_in_cond_item(&l_tx, &a_stake->tx_hash, l_prev_cond_idx, 0);
// add 'out_cond' item
@@ -537,9 +547,9 @@ dap_chain_net_srv_stake_item_t *s_stake_item_from_order(dap_chain_net_t *a_net,
log_it(L_WARNING, "Order is unsigned");
return NULL;
}
- dap_srv_stake_order_ext_t *l_ext = (dap_srv_stake_order_ext_t *)a_order->ext;
- dap_sign_t *l_sign = (dap_sign_t *)(&a_order->ext[a_order->ext_size]);
- if (!dap_sign_verify(l_sign, a_order, dap_chain_net_srv_order_get_size(a_order))) {
+ dap_srv_stake_order_ext_t *l_ext = (dap_srv_stake_order_ext_t *)a_order->ext_n_sign;
+ dap_sign_t *l_sign = (dap_sign_t *)(&a_order->ext_n_sign[a_order->ext_size]);
+ if (dap_sign_verify(l_sign, a_order, dap_chain_net_srv_order_get_size(a_order)) != 1) {
log_it(L_WARNING, "Order sign is invalid");
return NULL;
}
@@ -609,9 +619,9 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -coins");
return -7;
}
- uint64_t l_value = strtoull(l_coins_str, NULL, 10); // TODO add possibility to work with 256-bit format
- if (!l_value) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
+ uint256_t l_value = dap_chain_balance_scan(l_coins_str);
+ if (IS_ZERO_256(l_value)) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <256 bit integer>");
return -8;
}
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr_hldr", &l_addr_hldr_str);
@@ -695,9 +705,9 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order declare' required parameter -coins");
return -7;
}
- uint64_t l_value = strtoull(l_coins_str, NULL, 10); // TODO add possibility to work with 256-bit format
- if (!l_value) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
+ uint256_t l_value = dap_chain_balance_scan(l_coins_str);
+ if (IS_ZERO_256(l_value)) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <256 bit integer>");
return -8;
}
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
@@ -720,8 +730,8 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
dap_chain_node_cli_set_reply_text(a_str_reply, "Format -fee_percent <long double>(%)");
return -12;
}
- uint64_t l_balance = dap_chain_uint256_to(dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_token_str));
- if (l_balance < l_value) {
+ uint256_t l_balance = dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_token_str);
+ if (compare256(l_balance, l_value) == -1) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Insufficient coins for token %s in wallet '%s'", l_token_str, l_wallet_str);
return -13;
}
@@ -839,8 +849,8 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
}
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
if (l_coins_str) {
- uint64_t l_value = strtoull(l_coins_str, NULL, 10); // TODO add possibility to work with 256-bit format
- if (!l_value) {
+ uint256_t l_value = dap_chain_balance_scan(l_coins_str);
+ if (IS_ZERO_256(l_value)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
DAP_DELETE(l_stake);
return -8;
@@ -893,8 +903,8 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
return -18;
}
- uint64_t l_balance = dap_chain_uint256_to(dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_stake->token));
- if (l_balance < l_stake->value) {
+ uint256_t l_balance = dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_stake->token);
+ if (compare256(l_balance, l_stake->value) == -1) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Insufficient coins for token %s in wallet '%s'", l_token_str, l_wallet_str);
return -11;
}
@@ -952,8 +962,8 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
// TODO add filters to list (token, address, etc.)
l_stake = s_stake_item_from_order(l_net, l_order);
char *l_addr = dap_chain_addr_to_str(&l_stake->signing_addr);
- dap_string_append_printf(l_reply_str, "%s %"DAP_UINT64_FORMAT_U" %s %s %Lf\n", l_orders[i].key, l_stake->value, l_stake->token,
- l_addr, l_stake->fee_value);
+ dap_string_append_printf(l_reply_str, "%s %s %s %s %Lf\n", l_orders[i].key, dap_chain_balance_print(l_stake->value),
+ l_stake->token, l_addr, l_stake->fee_value);
DAP_DELETE(l_addr);
DAP_DELETE(l_stake);
}
@@ -1155,9 +1165,9 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
char *l_addr_hldr_str = dap_chain_addr_to_str(&l_stake->addr_hldr);
char *l_signing_addr_str = dap_chain_addr_to_str(&l_stake->signing_addr);
char *l_addr_fee_str = dap_chain_addr_to_str(&l_stake->addr_fee);
- dap_string_append_printf(l_reply_str, "%s %s %"DAP_UINT64_FORMAT_U" %s %s %s %Lf\n", l_tx_hash_str, l_stake->token,
- l_stake->value, l_addr_hldr_str, l_signing_addr_str,
- l_addr_fee_str, l_stake->fee_value);
+ dap_string_append_printf(l_reply_str, "%s %s %s %s %s %s %Lf\n", l_tx_hash_str, l_stake->token,
+ dap_chain_balance_print(l_stake->value), l_addr_hldr_str,
+ l_signing_addr_str, l_addr_fee_str, l_stake->fee_value);
DAP_DELETE(l_tx_hash_str);
DAP_DELETE(l_addr_hldr_str);
DAP_DELETE(l_signing_addr_str);
diff --git a/modules/service/stake/include/dap_chain_net_srv_stake.h b/modules/service/stake/include/dap_chain_net_srv_stake.h
index c539cee32af31515178a85a6355857e404ee3e55..a29606126b3f099cb0aa47cbe5a8bd945791765c 100644
--- a/modules/service/stake/include/dap_chain_net_srv_stake.h
+++ b/modules/service/stake/include/dap_chain_net_srv_stake.h
@@ -33,7 +33,7 @@ typedef struct dap_chain_net_srv_stake_item {
bool is_active;
dap_chain_net_t *net;
char token[DAP_CHAIN_TICKER_SIZE_MAX];
- uint64_t value;
+ uint256_t value;
dap_chain_addr_t addr_hldr;
dap_chain_addr_t addr_fee;
dap_chain_addr_t signing_addr;
diff --git a/modules/service/vpn/CMakeLists.txt b/modules/service/vpn/CMakeLists.txt
index 30e2258599f8a27aaac447963f2206034dbe6b67..973d4f0de12a4991ab6db17daf20989ce80582a5 100644
--- a/modules/service/vpn/CMakeLists.txt
+++ b/modules/service/vpn/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_vpn)
file(GLOB DAP_CHAIN_NET_SRV_VPN_SRCS *.c)
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn.c b/modules/service/vpn/dap_chain_net_srv_vpn.c
index 5c280e7e697c21e01d0aff944d401f2d0228166e..85226074bb64d509a0447aebe0c71c3cdf05c21a 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -58,7 +58,7 @@
#include <time.h>
#include <errno.h>
#include <signal.h>
-
+#include <stddef.h>
#include "uthash.h"
#include "utlist.h"
@@ -120,7 +120,7 @@ typedef struct tun_socket_msg{
} type;
dap_chain_net_srv_ch_vpn_t * ch_vpn;
dap_events_socket_t * esocket;
- uint128_t esocket_uuid;
+ dap_events_socket_uuid_t esocket_uuid;
bool is_reassigned_once;
union{
struct{ // Esocket reassigment
@@ -192,6 +192,7 @@ static void s_es_tun_new(dap_events_socket_t * a_es, void * arg);
static void s_es_tun_delete(dap_events_socket_t * a_es, void * arg);
static void s_es_tun_read(dap_events_socket_t * a_es, void * arg);
static void s_es_tun_error(dap_events_socket_t * a_es,int arg);
+static void s_es_tun_write(dap_events_socket_t *a_es, void *arg);
static void s_tun_recv_msg_callback(dap_events_socket_t * a_esocket_queue, void * a_msg );
static void s_tun_send_msg_ip_assigned(uint32_t a_worker_id, dap_chain_net_srv_ch_vpn_t * a_ch_vpn, struct in_addr a_addr);
@@ -204,9 +205,11 @@ static int s_tun_attach_queue(int fd);
static bool s_tun_client_send_data(dap_chain_net_srv_ch_vpn_info_t * a_ch_vpn_info, const void * a_data, size_t a_data_size);
-static size_t s_stream_session_esocket_send(dap_chain_net_srv_stream_session_t * l_srv_session, dap_events_socket_t * l_es, const void * a_data, size_t a_data_size );
static bool s_tun_client_send_data_unsafe(dap_chain_net_srv_ch_vpn_t * l_ch_vpn, ch_vpn_pkt_t * l_pkt_out);
+static void s_tun_fifo_write(dap_chain_net_srv_vpn_tun_socket_t *a_tun, ch_vpn_pkt_t *a_pkt);
+static ch_vpn_pkt_t *s_tun_fifo_read(dap_chain_net_srv_vpn_tun_socket_t *a_tun);
+
static bool s_tun_client_send_data_unsafe(dap_chain_net_srv_ch_vpn_t * l_ch_vpn, ch_vpn_pkt_t * l_pkt_out)
{
@@ -471,7 +474,7 @@ static void s_tun_send_msg_ip_unassigned_all(dap_chain_net_srv_ch_vpn_t * a_ch_v
*/
static void s_tun_send_msg_esocket_reasigned_inter(dap_chain_net_srv_vpn_tun_socket_t * a_tun_socket,
dap_chain_net_srv_ch_vpn_t * a_ch_vpn, dap_events_socket_t * a_esocket,
- uint128_t a_esocket_uuid, struct in_addr a_addr, uint32_t a_esocket_worker_id)
+ dap_events_socket_uuid_t a_esocket_uuid, struct in_addr a_addr, uint32_t a_esocket_worker_id)
{
struct tun_socket_msg * l_msg = DAP_NEW_Z(struct tun_socket_msg);
l_msg->type = TUN_SOCKET_MSG_ESOCKET_REASSIGNED ;
@@ -497,7 +500,7 @@ static void s_tun_send_msg_esocket_reasigned_inter(dap_chain_net_srv_vpn_tun_soc
* @param a_worker_id
*/
static void s_tun_send_msg_esocket_reasigned_all_inter(dap_chain_net_srv_ch_vpn_t * a_ch_vpn, dap_events_socket_t * a_esocket,
- uint128_t a_esocket_uuid, struct in_addr a_addr, uint32_t a_worker_id)
+ dap_events_socket_uuid_t a_esocket_uuid, struct in_addr a_addr, uint32_t a_worker_id)
{
for( uint32_t i=0; i< s_tun_sockets_count; i++)
s_tun_send_msg_esocket_reasigned_inter(s_tun_sockets[i] , a_ch_vpn, a_esocket, a_esocket_uuid, a_addr, a_worker_id);
@@ -519,10 +522,12 @@ static dap_events_socket_t * s_tun_event_stream_create(dap_worker_t * a_worker,
l_s_callbacks.read_callback = s_es_tun_read;
l_s_callbacks.error_callback = s_es_tun_error;
l_s_callbacks.delete_callback = s_es_tun_delete;
+ l_s_callbacks.write_callback = s_es_tun_write;
dap_events_socket_t * l_es = dap_events_socket_wrap_no_add(a_worker->events ,
a_tun_fd, &l_s_callbacks);
l_es->type = DESCRIPTOR_TYPE_FILE;
+ l_es->no_close = true;
dap_events_socket_assign_on_worker_mt(l_es, a_worker);
return l_es;
@@ -1454,23 +1459,46 @@ void s_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
// for client only
case VPN_PACKET_OP_CODE_VPN_RECV:{
a_ch->stream->esocket->last_ping_request = time(NULL); // not ping, but better ;-)
- //ch_sf_tun_client_send(CH_VPN(a_ch), l_vpn_pkt->data, l_vpn_pkt->header.op_data.data_size);
dap_events_socket_t *l_es = dap_chain_net_vpn_client_tun_get_esock();
// Find tun socket for current worker
dap_chain_net_srv_vpn_tun_socket_t *l_tun = l_es ? l_es->_inheritor : NULL;
//ch_sf_tun_socket_t * l_tun = s_tun_sockets[a_ch->stream_worker->worker->id];
assert(l_tun);
- s_stream_session_esocket_send(l_srv_session, l_tun->es, l_vpn_pkt->data, l_vpn_pkt->header.op_data.data_size);
+ size_t l_ret = dap_events_socket_write_unsafe(l_tun->es, l_vpn_pkt->data, l_vpn_pkt->header.op_data.data_size);
+ if (l_ret == l_vpn_pkt->header.op_data.data_size) {
+ l_srv_session->stats.packets_sent++;
+ l_srv_session->stats.bytes_sent += l_ret;
+ } else if (l_ret > 0) {
+ log_it (L_WARNING, "Lost %zd bytes, buffer overflow", l_vpn_pkt->header.op_data.data_size - l_ret);
+ l_srv_session->stats.bytes_sent_lost += (l_vpn_pkt->header.op_data.data_size - l_ret);
+ l_srv_session->stats.packets_sent_lost++;
+ }
} break;
// for server only
case VPN_PACKET_OP_CODE_VPN_SEND: {
dap_chain_net_srv_vpn_tun_socket_t * l_tun = s_tun_sockets[a_ch->stream_worker->worker->id];
assert(l_tun);
- // Unsafely send it
- size_t l_ret = s_stream_session_esocket_send(l_srv_session, l_tun->es, l_vpn_pkt->data, l_vpn_pkt->header.op_data.data_size);
- if( l_ret)
- s_update_limits (a_ch, l_srv_session, l_usage,l_ret );
+ size_t l_size_to_send = l_vpn_pkt->header.op_data.data_size;
+ ssize_t l_ret = write(l_tun->es->fd, l_vpn_pkt->data, l_size_to_send);
+ if (l_ret > 0) {
+ s_update_limits(a_ch, l_srv_session, l_usage, l_ret);
+ if (l_ret == l_size_to_send) {
+ l_srv_session->stats.packets_sent++;
+ l_srv_session->stats.bytes_sent += l_ret;
+ } else {
+ log_it (L_WARNING, "Lost %zd bytes", l_size_to_send - l_ret);
+ l_srv_session->stats.bytes_sent_lost += (l_size_to_send - l_ret);
+ l_srv_session->stats.packets_sent_lost++;
+ }
+ } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
+ s_tun_fifo_write(l_tun, l_vpn_pkt);
+ dap_events_socket_set_writable_unsafe(l_tun->es, true);
+ } else {
+ char l_errbuf[128];
+ strerror_r(errno, l_errbuf, sizeof (l_errbuf));
+ log_it(L_WARNING,"Error with data sent: \"%s\" code %d", l_errbuf, errno);
+ }
} break;
default:
log_it(L_WARNING, "Can't process SF type 0x%02x", l_vpn_pkt->header.op_code);
@@ -1478,59 +1506,6 @@ void s_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
}
}
-/**
- * @brief s_stream_session_esocket_send
- * @param l_srv_session
- * @param l_es
- * @param a_data
- * @param a_data_size
- */
-static size_t s_stream_session_esocket_send(dap_chain_net_srv_stream_session_t * l_srv_session, dap_events_socket_t * l_es, const void * a_data, size_t a_data_size )
-{
- // Lets first try to send it directly with write() call
- ssize_t l_direct_wrote;
- size_t l_ret = 0;
- if (l_es->type == DESCRIPTOR_TYPE_FILE )
- l_direct_wrote = write(l_es->fd, a_data, a_data_size);
- else
- l_direct_wrote = send(l_es->fd, a_data, a_data_size, MSG_DONTWAIT | MSG_NOSIGNAL);
- int l_errno = errno;
-
- size_t l_data_left_to_send=0;
- if (l_direct_wrote > 0){
- l_ret += l_direct_wrote;
- if((size_t) l_direct_wrote < a_data_size){ // If we sent not all - lets put tail in buffer
- l_data_left_to_send = a_data_size-l_direct_wrote;
- }else{
- l_srv_session->stats.packets_sent++;
- l_srv_session->stats.bytes_sent+= l_direct_wrote;
- }
- }else{
- l_data_left_to_send = a_data_size;
- l_direct_wrote=0;
- if(l_errno != EAGAIN && l_errno != EWOULDBLOCK){
- char l_errbuf[128];
- strerror_r(l_errno, l_errbuf, sizeof (l_errbuf));
- log_it(L_WARNING,"Error with data sent: \"%s\" code %d",l_errbuf, l_errno);
- }
- }
-
- if(l_data_left_to_send){
- //if ( dap_events_socket_write_unsafe( l_es, a_data +l_direct_wrote,l_data_left_to_send
- // ) < l_data_left_to_send ){
- //log_it(L_WARNING,"Loosing data, probably buffers are overfilling, lost %zd bytes", l_data_left_to_send);
- log_it(L_WARNING,"Loosing data, lost %zd bytes", l_data_left_to_send);
- l_srv_session->stats.bytes_sent_lost += l_data_left_to_send;
- l_srv_session->stats.packets_sent_lost++;
- /*}else{
- l_ret += l_data_left_to_send;
- l_srv_session->stats.packets_sent++;
- l_srv_session->stats.bytes_sent+= l_direct_wrote;
- }*/
- }
- return l_ret;
-}
-
/**
* @brief stream_sf_packet_out Packet Out Ch callback
* @param ch
@@ -1572,6 +1547,25 @@ static void s_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
}
+static void s_tun_fifo_write(dap_chain_net_srv_vpn_tun_socket_t *a_tun, ch_vpn_pkt_t *a_pkt)
+{
+ if (!a_tun || !a_pkt)
+ return;
+ a_tun->fifo = dap_list_append(a_tun->fifo, DAP_DUP_SIZE(a_pkt,
+ a_pkt->header.op_data.data_size + sizeof(a_pkt->header)));
+}
+
+static ch_vpn_pkt_t *s_tun_fifo_read(dap_chain_net_srv_vpn_tun_socket_t *a_tun)
+{
+ if (!a_tun || !a_tun->fifo)
+ return NULL;
+ ch_vpn_pkt_t *l_ret = (ch_vpn_pkt_t *)a_tun->fifo->data;
+ dap_list_t *l_to_delete = a_tun->fifo;
+ a_tun->fifo = a_tun->fifo->next;
+ DAP_DELETE(l_to_delete);
+ return l_ret;
+}
+
/**
* @brief m_es_tun_delete
* @param a_es
@@ -1580,9 +1574,34 @@ static void s_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
static void s_es_tun_delete(dap_events_socket_t * a_es, void * arg)
{
(void) arg;
- s_tun_sockets[a_es->worker->id] = NULL;
- dap_events_socket_remove_and_delete_unsafe(s_tun_sockets_queue_msg[a_es->worker->id],false);
- log_it(L_NOTICE,"Destroyed TUN event socket");
+ if (a_es->worker) {
+ s_tun_sockets[a_es->worker->id] = NULL;
+ dap_events_socket_remove_and_delete_unsafe(s_tun_sockets_queue_msg[a_es->worker->id],false);
+ log_it(L_NOTICE,"Destroyed TUN event socket");
+ }
+}
+
+/**
+ * @brief s_es_tun_write
+ * @param a_es
+ * @param arg
+ */
+static void s_es_tun_write(dap_events_socket_t *a_es, void *arg)
+{
+ (void) arg;
+ dap_chain_net_srv_vpn_tun_socket_t *l_tun = CH_SF_TUN_SOCKET(a_es);
+ assert(l_tun);
+ ch_vpn_pkt_t *l_vpn_pkt = (ch_vpn_pkt_t *)l_tun->fifo->data;
+ if (!l_vpn_pkt)
+ return;
+ a_es->buf_out_zero_count = 0;
+ size_t l_size_to_send = l_vpn_pkt->header.op_data.data_size;
+ ssize_t l_ret = write(l_tun->es->fd, l_vpn_pkt->data, l_size_to_send);
+ if (l_ret < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+ return;
+ }
+ s_tun_fifo_read(l_tun);
+ DAP_DELETE(l_vpn_pkt);
}
/**
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index 8383b3203c0535bf3af4f7d90b6e755a08f8b88e..5b14c54079f4daebb088547b7e63aa5f63a5c707 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -240,8 +240,9 @@ static dap_chain_hash_fast_t* dap_chain_net_vpn_client_tx_cond_hash(dap_chain_ne
dap_chain_addr_t *l_addr_from = dap_chain_wallet_get_addr(l_wallet_from, a_net->pub.id);
dap_chain_net_srv_price_unit_uid_t l_price_unit = { .enm = SERV_UNIT_SEC };
dap_chain_net_srv_uid_t l_srv_uid = { .uint64 = DAP_CHAIN_NET_SRV_VPN_ID };
+ uint256_t l_value = dap_chain_uint256_from(a_value_datoshi);
l_tx_cond_hash = dap_chain_proc_tx_create_cond(a_net, l_key_from, l_client_key, l_addr_from,
- a_token_ticker, a_value_datoshi, 0, l_price_unit, l_srv_uid, 0, l_pub_key_data, l_pub_key_data_size);
+ a_token_ticker, l_value, uint256_0, l_price_unit, l_srv_uid, uint256_0, l_pub_key_data, l_pub_key_data_size);
//char *l_addr_from_str = dap_chain_addr_to_str(l_addr_from);
DAP_DELETE(l_addr_from);
if(!l_tx_cond_hash) {
@@ -356,7 +357,8 @@ char *dap_chain_net_vpn_client_check_result(dap_chain_net_t *a_net, const char*
dap_chain_net_srv_order_t * l_orders = NULL;
size_t l_orders_num = 0;
dap_chain_net_srv_uid_t l_srv_uid = { { 0 } };
- uint64_t l_price_min = 0, l_price_max = 0;
+ uint256_t l_price_min = {};
+ uint256_t l_price_max = {};
dap_chain_net_srv_price_unit_uid_t l_price_unit = { { 0 } };
dap_chain_net_srv_order_direction_t l_direction = SERV_DIR_UNDEFINED;
dap_string_t *l_string_ret = dap_string_new("");
diff --git a/modules/service/vpn/include/dap_chain_net_srv_vpn.h b/modules/service/vpn/include/dap_chain_net_srv_vpn.h
index 810330bb7b254f9dde8bb34a31a4b9db14fd1382..a576bc5ca2b1d35298d2e17addf9f5d9c061352d 100644
--- a/modules/service/vpn/include/dap_chain_net_srv_vpn.h
+++ b/modules/service/vpn/include/dap_chain_net_srv_vpn.h
@@ -112,6 +112,7 @@ typedef struct dap_chain_net_srv_vpn_tun_socket {
dap_events_socket_t * es;
dap_chain_net_srv_ch_vpn_info_t * clients; // Remote clients identified by destination address
dap_events_socket_t ** queue_tun_msg_input;
+ dap_list_t *fifo;
//UT_hash_handle hh;
}dap_chain_net_srv_vpn_tun_socket_t;
@@ -149,7 +150,7 @@ typedef struct dap_chain_net_srv_ch_vpn_info
dap_events_socket_t * queue_msg; // Message queue
dap_worker_t * worker;
dap_events_socket_t * esocket;
- uint64_t esocket_uuid;
+ dap_events_socket_uuid_t esocket_uuid;
UT_hash_handle hh;
}dap_chain_net_srv_ch_vpn_info_t;
diff --git a/modules/service/xchange/CMakeLists.txt b/modules/service/xchange/CMakeLists.txt
index c6b509051eb664c3ea4dba7b4939eda69681aca8..b3ee5a1c988275abd4e389a0f520f01640b2a54a 100644
--- a/modules/service/xchange/CMakeLists.txt
+++ b/modules/service/xchange/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_net_srv_xchange)
file(GLOB DAP_SRV_XCHANGE_SRCS *.c)
diff --git a/modules/service/xchange/dap_chain_net_srv_xchange.c b/modules/service/xchange/dap_chain_net_srv_xchange.c
index 45662257bd4190e85330d488f3b1963fa0b1f055..35173aa639a780b440d034d4ee4fe7bc5f4770bb 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -109,8 +109,7 @@ bool dap_chain_net_srv_xchange_verificator(dap_chain_tx_out_cond_t *a_cond, dap_
* a_cond.srv_xchange.rate >= a_tx.out.rate
*/
dap_list_t *l_list_out = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_EXT, NULL);
- long double l_seller_rate = (long double)a_cond->header.value / a_cond->subtype.srv_xchange.value;
- uint64_t l_out_val = 0, l_back_val = 0;
+ uint256_t l_out_val = {}, l_back_val = {};
char *l_ticker_ctrl = NULL;
for (dap_list_t *l_list_tmp = l_list_out; l_list_tmp; l_list_tmp = l_list_tmp->next) {
dap_chain_tx_out_ext_t *l_tx_out = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
@@ -122,13 +121,18 @@ bool dap_chain_net_srv_xchange_verificator(dap_chain_tx_out_cond_t *a_cond, dap_
return false; // too many tokens
}
l_ticker_ctrl = l_tx_out->token;
- l_back_val += l_tx_out->header.value;
+ SUM_256_256(l_back_val, l_tx_out->header.value, &l_back_val);
} else { // buying token
- l_out_val += l_tx_out->header.value;
+ SUM_256_256(l_out_val, l_tx_out->header.value, &l_out_val);
}
}
- long double l_buyer_rate = (a_cond->header.value - l_back_val) / (long double)l_out_val;
- if (l_seller_rate < l_buyer_rate) {
+ //long double l_buyer_rate = (a_cond->header.value - l_back_val) / (long double)l_out_val;
+ //long double l_seller_rate = (long double)a_cond->header.value / a_cond->subtype.srv_xchange.value;
+ uint256_t l_buyer_val = {}, l_buyer_mul = {}, l_seller_mul = {};
+ SUBTRACT_256_256(a_cond->header.value, l_back_val, &l_buyer_val);
+ MULT_256_256(l_buyer_val, a_cond->subtype.srv_xchange.value, &l_buyer_mul);
+ MULT_256_256(l_out_val, a_cond->header.value, &l_seller_mul);
+ if (compare256(l_seller_mul, l_buyer_mul) == -1) {
return false; // wrong changing rate
}
return true;
@@ -136,11 +140,11 @@ bool dap_chain_net_srv_xchange_verificator(dap_chain_tx_out_cond_t *a_cond, dap_
static dap_chain_datum_tx_receipt_t *s_xchage_receipt_create(dap_chain_net_srv_xchange_price_t *a_price)
{
- uint32_t l_ext_size = sizeof(uint64_t) + DAP_CHAIN_TICKER_SIZE_MAX;
+ uint32_t l_ext_size = sizeof(uint256_t) + DAP_CHAIN_TICKER_SIZE_MAX;
uint8_t *l_ext = DAP_NEW_SIZE(uint8_t, l_ext_size);
- uint64_t l_datoshi_buy = (long double)a_price->datoshi_sell / a_price->rate;
- dap_lendian_put64(l_ext, l_datoshi_buy);
- strcpy((char *)&l_ext[sizeof(uint64_t)], a_price->token_buy);
+ uint256_t l_datoshi_buy = MULT_256_FLOAT(a_price->datoshi_sell, 1 / a_price->rate);
+ memcpy(l_ext, &l_datoshi_buy, sizeof(uint256_t));
+ strcpy((char *)&l_ext[sizeof(uint256_t)], a_price->token_buy);
dap_chain_net_srv_price_unit_uid_t l_unit = { .uint32 = SERV_UNIT_UNDEFINED};
dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_XCHANGE_ID };
dap_chain_datum_tx_receipt_t *l_receipt = dap_chain_datum_tx_receipt_create(l_uid, l_unit, 0, a_price->datoshi_sell,
@@ -160,7 +164,7 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_request(dap_chain_net_srv_xchan
dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name(a_price->net_sell->pub.name);
dap_chain_addr_t *l_seller_addr = (dap_chain_addr_t *)dap_chain_wallet_get_addr(a_wallet, a_price->net_sell->pub.id);
dap_enc_key_t *l_seller_key = dap_chain_wallet_get_key(a_wallet, 0);
- uint64_t l_value_sell = 0; // how many coins to transfer
+ uint256_t l_value_sell = {}; // how many coins to transfer
// list of transaction with 'out' items to sell
dap_list_t *l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(l_ledger, a_price->token_sell,
l_seller_addr, a_price->datoshi_sell, &l_value_sell);
@@ -172,9 +176,9 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_request(dap_chain_net_srv_xchan
}
// add 'in' items to sell
- uint64_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
+ uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
dap_list_free_full(l_list_used_out, free);
- if (l_value_to_items != l_value_sell) {
+ if (compare256(l_value_to_items, l_value_sell) != 0) {
dap_chain_datum_tx_delete(l_tx);
DAP_DELETE(l_seller_addr);
log_it(L_ERROR, "Can't compose the transaction input");
@@ -196,8 +200,9 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_request(dap_chain_net_srv_xchan
dap_chain_datum_tx_add_item(&l_tx, (const uint8_t *)l_tx_out);
DAP_DELETE(l_tx_out);
// coin back
- uint64_t l_value_back = l_value_sell - a_price->datoshi_sell;
- if (l_value_back) {
+ uint256_t l_value_back = {};
+ SUBTRACT_256_256(l_value_sell, a_price->datoshi_sell, &l_value_back);
+ if (!IS_ZERO_256(l_value_back)) {
if (dap_chain_datum_tx_add_out_item(&l_tx, l_seller_addr, l_value_back) != 1) {
dap_chain_datum_tx_delete(l_tx);
DAP_DELETE(l_seller_addr);
@@ -230,9 +235,9 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_exchange(dap_chain_net_srv_xcha
dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name(a_price->net_buy->pub.name);
dap_chain_addr_t *l_seller_addr = (dap_chain_addr_t *)dap_chain_wallet_get_addr(a_wallet, a_price->net_buy->pub.id);
dap_enc_key_t *l_seller_key = dap_chain_wallet_get_key(a_wallet, 0);
- uint64_t l_value_buy = 0; // how many coins to transfer
+ uint256_t l_value_buy = {}; // how many coins to transfer
// list of transaction with 'out' items to sell
- uint64_t l_datoshi_buy = ceill(a_price->datoshi_sell / a_price->rate);
+ uint256_t l_datoshi_buy = MULT_256_FLOAT(a_price->datoshi_sell, 1 / a_price->rate);
dap_list_t *l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(l_ledger, a_price->token_buy,
l_seller_addr, l_datoshi_buy, &l_value_buy);
if(!l_list_used_out) {
@@ -246,9 +251,9 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_exchange(dap_chain_net_srv_xcha
dap_chain_datum_tx_add_item(&l_tx, (byte_t *)l_receipt);
DAP_DELETE(l_receipt);
// add 'in' items to sell
- uint64_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
+ uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
dap_list_free_full(l_list_used_out, free);
- if (l_value_to_items != l_value_buy) {
+ if (compare256(l_value_to_items, l_value_buy) != 0) {
dap_chain_datum_tx_delete(l_tx);
DAP_DELETE(l_seller_addr);
log_it(L_ERROR, "Can't compose the transaction input");
@@ -278,8 +283,9 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_exchange(dap_chain_net_srv_xcha
return NULL;
}
// coin back
- uint64_t l_value_back = l_value_buy - l_datoshi_buy;
- if (l_value_back) {
+ uint256_t l_value_back = {};
+ SUBTRACT_256_256(l_value_buy, l_datoshi_buy, &l_value_back);
+ if (!IS_ZERO_256(l_value_back)) {
if (dap_chain_datum_tx_add_out_ext_item(&l_tx, l_seller_addr, l_value_back, a_price->token_buy) == -1) {
dap_chain_datum_tx_delete(l_tx);
DAP_DELETE(l_seller_addr);
@@ -296,9 +302,8 @@ static dap_chain_datum_tx_t *s_xchange_tx_create_exchange(dap_chain_net_srv_xcha
}
DAP_DELETE(l_seller_addr);
//transfer unbuying coins (partial exchange)
- uint64_t l_buying_value = l_tx_out_cond->header.value;
- l_value_back = l_buying_value - a_price->datoshi_sell;
- if (l_value_back) {
+ SUBTRACT_256_256(l_tx_out_cond->header.value, a_price->datoshi_sell, &l_value_back);
+ if (!IS_ZERO_256(l_value_back)) {
if (dap_chain_datum_tx_add_out_ext_item(&l_tx, l_buyer_addr, l_value_back, a_price->token_sell) == -1) {
log_it(L_WARNING, "Can't add buying coins back output (cashback)");
return NULL;
@@ -397,14 +402,14 @@ char *s_xchange_order_create(dap_chain_net_srv_xchange_price_t *a_price, dap_cha
dap_hash_fast(a_tx, dap_chain_datum_tx_get_size(a_tx), &l_tx_hash);
memcpy(&a_price->tx_hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t));
dap_srv_xchange_order_ext_t l_ext;
- dap_lendian_put64((uint8_t *)&l_ext.net_sell_id, a_price->net_sell->pub.id.uint64);
- dap_lendian_put64((uint8_t *)&l_ext.datoshi_sell, a_price->datoshi_sell);
+ l_ext.net_sell_id = a_price->net_sell->pub.id.uint64;
+ l_ext.datoshi_sell = a_price->datoshi_sell;
strcpy(l_ext.token_sell, a_price->token_sell);
uint32_t l_ext_size = sizeof(dap_srv_xchange_order_ext_t);
dap_chain_node_addr_t *l_node_addr = dap_chain_net_get_cur_addr(a_price->net_sell);
dap_chain_net_srv_price_unit_uid_t l_unit = { .uint32 = SERV_UNIT_UNDEFINED};
dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_XCHANGE_ID };
- uint64_t l_datoshi_buy = ceill(a_price->datoshi_sell / a_price->rate);
+ uint256_t l_datoshi_buy = MULT_256_FLOAT(a_price->datoshi_sell, 1 / a_price->rate);
char *l_order_hash_str = dap_chain_net_srv_order_create(a_price->net_buy, SERV_DIR_SELL, l_uid, *l_node_addr,
l_tx_hash, l_datoshi_buy, l_unit, a_price->token_buy, 0,
(uint8_t *)&l_ext, l_ext_size, NULL, 0, NULL);
@@ -414,14 +419,14 @@ char *s_xchange_order_create(dap_chain_net_srv_xchange_price_t *a_price, dap_cha
dap_chain_net_srv_xchange_price_t *s_xchange_price_from_order(dap_chain_net_t *a_net, dap_chain_net_srv_order_t *a_order)
{
dap_chain_net_srv_xchange_price_t *l_price = DAP_NEW_Z(dap_chain_net_srv_xchange_price_t);
- dap_srv_xchange_order_ext_t *l_ext = (dap_srv_xchange_order_ext_t *)a_order->ext;
+ dap_srv_xchange_order_ext_t *l_ext = (dap_srv_xchange_order_ext_t *)a_order->ext_n_sign;
dap_chain_net_id_t l_net_buy_id = { .uint64 = dap_lendian_get64((uint8_t *)&l_ext->net_sell_id) };
l_price->net_sell = dap_chain_net_by_id(l_net_buy_id);
- l_price->datoshi_sell = dap_lendian_get64((uint8_t *)&l_ext->datoshi_sell);
+ l_price->datoshi_sell = l_ext->datoshi_sell;
strcpy(l_price->token_sell, l_ext->token_sell);
l_price->net_buy = a_net;
strcpy(l_price->token_buy, a_order->price_ticker);
- l_price->rate = (long double)l_price->datoshi_sell / a_order->price;
+ l_price->rate = 1; // TODO (long double)l_price->datoshi_sell / a_order->price;
return l_price;
}
@@ -547,8 +552,8 @@ static int s_cli_srv_xchange_price(int a_argc, char **a_argv, int a_arg_index, c
dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price create' required parameter -coins");
return -8;
}
- uint64_t l_datoshi_sell = strtoull(l_val_sell_str, NULL, 10);
- if (!l_datoshi_sell) {
+ uint256_t l_datoshi_sell = dap_chain_balance_scan(l_val_sell_str);
+ if (IS_ZERO_256(l_datoshi_sell)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
return -9;
}
@@ -572,9 +577,8 @@ static int s_cli_srv_xchange_price(int a_argc, char **a_argv, int a_arg_index, c
dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
return -11;
}
- uint256_t l_balance = dap_chain_wallet_get_balance(l_wallet, l_net_sell->pub.id, l_token_sell_str);
- uint64_t l_value = dap_chain_uint256_to(l_balance);
- if (l_value < l_datoshi_sell) {
+ uint256_t l_value = dap_chain_wallet_get_balance(l_wallet, l_net_sell->pub.id, l_token_sell_str);
+ if (compare256(l_value, l_datoshi_sell) == -1) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Not enough cash in specified wallet");
dap_chain_wallet_close(l_wallet);
return -12;
@@ -666,13 +670,13 @@ static int s_cli_srv_xchange_price(int a_argc, char **a_argv, int a_arg_index, c
*a_str_reply = dap_string_free(l_str_reply, false);
} else { // CMD_UPDATE
const char *l_val_sell_str = NULL, *l_val_rate_str = NULL, *l_wallet_str = NULL, *l_new_wallet_str = NULL;
- uint64_t l_datoshi_sell = 0;
+ uint256_t l_datoshi_sell = {};
long double l_rate = 0;
dap_chain_wallet_t *l_wallet = NULL;
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_sell_str);
if (l_val_sell_str) {
- l_datoshi_sell = strtoull(l_val_sell_str, NULL, 10);
- if (!l_datoshi_sell) {
+ l_datoshi_sell = dap_chain_balance_scan(l_val_sell_str);
+ if (IS_ZERO_256(l_datoshi_sell)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
return -9;
}
@@ -696,9 +700,8 @@ static int s_cli_srv_xchange_price(int a_argc, char **a_argv, int a_arg_index, c
dap_chain_node_cli_set_reply_text(a_str_reply, "At least one of updating parameters is mandatory");
return -13;
}
- uint256_t l_balance = dap_chain_wallet_get_balance(l_wallet, l_net_sell->pub.id, l_token_sell_str);
- uint64_t l_value = dap_chain_uint256_to(l_balance);
- if (l_datoshi_sell && l_value < l_datoshi_sell) {
+ uint256_t l_value = dap_chain_wallet_get_balance(l_wallet, l_net_sell->pub.id, l_token_sell_str);
+ if (!IS_ZERO_256(l_datoshi_sell) && compare256(l_value, l_datoshi_sell) == -1) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Not enough cash in specified wallet");
dap_chain_wallet_close(l_wallet);
return -12;
@@ -768,9 +771,9 @@ static int s_cli_srv_xchange_price(int a_argc, char **a_argv, int a_arg_index, c
dap_string_t *l_reply_str = dap_string_new("");
HASH_ITER(hh, s_srv_xchange->pricelist, l_price, l_tmp) {
char *l_order_hash_str = dap_chain_hash_fast_to_str_new(&l_price->order_hash);
- dap_string_append_printf(l_reply_str, "%s %s %s %s %s %"DAP_UINT64_FORMAT_U" %Lf %s\n", l_order_hash_str, l_price->token_sell,
+ dap_string_append_printf(l_reply_str, "%s %s %s %s %s %s %Lf %s\n", l_order_hash_str, l_price->token_sell,
l_price->net_sell->pub.name, l_price->token_buy, l_price->net_buy->pub.name,
- l_price->datoshi_sell, l_price->rate, l_price->wallet_str);
+ dap_chain_balance_print(l_price->datoshi_sell), l_price->rate, l_price->wallet_str);
DAP_DELETE(l_order_hash_str);
}
if (!l_reply_str->len) {
@@ -835,9 +838,9 @@ static int s_cli_srv_xchange(int a_argc, char **a_argv, char **a_str_reply)
continue;
// TODO add filters to list (tokens, network, etc.)
l_price = s_xchange_price_from_order(l_net, l_order);
- dap_string_append_printf(l_reply_str, "%s %s %s %s %s %"DAP_UINT64_FORMAT_U" %Lf\n", l_orders[i].key, l_price->token_sell,
+ dap_string_append_printf(l_reply_str, "%s %s %s %s %s %s %Lf\n", l_orders[i].key, l_price->token_sell,
l_price->net_sell->pub.name, l_price->token_buy, l_price->net_buy->pub.name,
- l_price->datoshi_sell, l_price->rate);
+ dap_chain_balance_print(l_price->datoshi_sell), l_price->rate);
DAP_DELETE(l_price);
}
dap_chain_global_db_objs_delete(l_orders, l_orders_count);
@@ -880,8 +883,8 @@ static int s_cli_srv_xchange(int a_argc, char **a_argv, char **a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'purchase' required parameter -coins");
return -8;
}
- uint64_t l_datoshi_sell = strtoull(l_val_sell_str, NULL, 10);
- if (!l_datoshi_sell) {
+ uint256_t l_datoshi_sell = dap_chain_balance_scan(l_val_sell_str);
+ if (IS_ZERO_256(l_datoshi_sell)) {
dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
return -9;
}
diff --git a/modules/service/xchange/include/dap_chain_net_srv_xchange.h b/modules/service/xchange/include/dap_chain_net_srv_xchange.h
index 0e098f7c67445ac7dfcca10a0ef964fc24feb3e8..f7ffaafed5d505832743cf338ae6f91f9151b0b5 100644
--- a/modules/service/xchange/include/dap_chain_net_srv_xchange.h
+++ b/modules/service/xchange/include/dap_chain_net_srv_xchange.h
@@ -34,7 +34,7 @@ typedef struct dap_chain_net_srv_xchange_price {
char *wallet_str;
dap_chain_net_t *net_sell;
char token_sell[DAP_CHAIN_TICKER_SIZE_MAX];
- uint64_t datoshi_sell;
+ uint256_t datoshi_sell;
dap_chain_net_t *net_buy;
char token_buy[DAP_CHAIN_TICKER_SIZE_MAX];
long double rate;
@@ -50,7 +50,7 @@ typedef struct dap_chain_net_srv_xchange_db_item {
uint8_t padding[4];
uint64_t net_sell_id;
uint64_t net_buy_id;
- uint64_t datoshi_sell;
+ uint256_t datoshi_sell;
long double rate;
dap_chain_hash_fast_t tx_hash;
dap_chain_hash_fast_t order_hash;
@@ -59,7 +59,7 @@ typedef struct dap_chain_net_srv_xchange_db_item {
typedef struct dap_srv_xchange_order_ext {
uint64_t net_sell_id;
- uint64_t datoshi_sell;
+ uint256_t datoshi_sell;
char token_sell[DAP_CHAIN_TICKER_SIZE_MAX];
} dap_srv_xchange_order_ext_t;
diff --git a/modules/test/CMakeLists.txt b/modules/test/CMakeLists.txt
index b48617d0f087fa6a5e14e6113595548353fe63cb..0f12e79311ce376b646fefa2097a757b110f9d6e 100644
--- a/modules/test/CMakeLists.txt
+++ b/modules/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
if(TARGET dap_test)
return() # The project has already been built.
endif()
diff --git a/modules/type/blocks/CMakeLists.txt b/modules/type/blocks/CMakeLists.txt
index 0c377cec8c870d5b1959ac79eadfad106d78e0a6..cc15e054ac95f21b59e3c0d371823d43f222f65d 100644
--- a/modules/type/blocks/CMakeLists.txt
+++ b/modules/type/blocks/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_blocks)
file(GLOB DAP_CHAIN_BLOCK_SRCS *.c)
diff --git a/modules/type/blocks/dap_chain_block.c b/modules/type/blocks/dap_chain_block.c
index 4bc564e15eb26fe7d0e5691dfaf8902ae829b98a..cd45d3bf89248d2d0d6564934a813a668b4dfcd9 100644
--- a/modules/type/blocks/dap_chain_block.c
+++ b/modules/type/blocks/dap_chain_block.c
@@ -22,10 +22,10 @@
*/
#include <stddef.h>
#include "string.h"
+#include "dap_chain_net.h"
#include "dap_common.h"
#include "dap_config.h"
#include "dap_hash.h"
-#include "dap_chain_net.h"
#include "dap_chain_block.h"
#include "dap_chain_block_cache.h"
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 192b6211fb370cc1a792388ab7737ae8903068ed..61ba34df74265bd78efa982cd3d8c3758d134346 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -105,7 +105,7 @@ static dap_chain_atom_verify_res_t s_callback_atom_verify(dap_chain_t * a_chain,
// Get block header size
static size_t s_callback_atom_get_static_hdr_size(void);
-static dap_chain_atom_iter_t* s_callback_atom_iter_create(dap_chain_t * a_chain , dap_chain_cell_id_t a_cell_id);
+static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id);
static dap_chain_atom_iter_t* s_callback_atom_iter_create_from(dap_chain_t * ,
dap_chain_atom_ptr_t , size_t);
@@ -456,13 +456,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
size_t l_block_size = 0;
dap_chain_hash_fast_t l_block_hash={0};
dap_enc_base58_hex_to_hash( l_subcmd_str_arg, &l_block_hash); // Convert argument to hash
- dap_chain_cell_t *l_cell = l_chain->cells;
- do {
- l_block = (dap_chain_block_t *)dap_chain_get_atom_by_hash(l_chain, &l_block_hash, &l_block_size, l_cell->id);
- if (l_block)
- break;
- l_cell = l_cell->hh.next;
- } while (l_cell);
+ l_block = (dap_chain_block_t*) dap_chain_get_atom_by_hash( l_chain, &l_block_hash, &l_block_size);
if ( l_block){
dap_chain_block_cache_t *l_block_cache = dap_chain_block_cs_cache_get_by_hash(l_blocks, &l_block_hash);
if ( l_block_cache ){
@@ -527,7 +521,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
ctime_r(&l_datum_ts_create, buf);
dap_string_append_printf(l_str_tmp,"\t\t\t\tts_create=%s\n", buf);
dap_string_append_printf(l_str_tmp,"\t\t\t\tdata_size=%u\n", l_datum->header.data_size);
- dap_chain_net_dump_datum(l_str_tmp, l_datum, "hex" );
+ dap_chain_net_dump_datum(l_str_tmp, l_datum, "hex");
}
// Signatures
dap_string_append_printf(l_str_tmp,"\t\tsignatures:\tcount: %zu\n",l_block_cache->sign_count );
@@ -624,17 +618,12 @@ static int s_add_atom_to_ledger(dap_chain_cs_blocks_t * a_blocks, dap_ledger_t
for(size_t i=0; i<a_block_cache->datum_count; i++){
dap_chain_datum_t *l_datum = a_block_cache->datum[i];
switch (l_datum->header.type_id) {
- case DAP_CHAIN_DATUM_256_TOKEN_DECL:
case DAP_CHAIN_DATUM_TOKEN_DECL: {
dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
- l_ret=dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
+ l_ret = dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
} break;
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
- // l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- // true : false;
- l_ret=dap_chain_ledger_token_emission_load(a_ledger, (dap_chain_datum_token_emission_t*) l_datum->data, l_datum->header.data_size);
+ l_ret = dap_chain_ledger_token_emission_load(a_ledger, l_datum->data, l_datum->header.data_size);
} break;
case DAP_CHAIN_DATUM_TX: {
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
@@ -909,11 +898,11 @@ static size_t s_callback_atom_get_static_hdr_size(void)
* @param a_chain
* @return
*/
-static dap_chain_atom_iter_t* s_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id)
+static dap_chain_atom_iter_t *s_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id)
{
dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
l_atom_iter->chain = a_chain;
- l_atom_iter->cell_id.uint64 = a_cell_id.uint64;
+ l_atom_iter->cell_id = a_cell_id;
l_atom_iter->_inheritor = DAP_NEW_Z(dap_chain_cs_blocks_iter_t);
ITER_PVT(l_atom_iter)->blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
@@ -1163,6 +1152,7 @@ static size_t s_callback_add_datums(dap_chain_t *a_chain, dap_chain_datum_t **a_
pthread_rwlock_wrlock(&l_blocks_pvt->datums_lock);
if (!l_blocks->block_new) {
l_blocks->block_new = dap_chain_block_new(&l_blocks_pvt->block_cache_last->block_hash, &l_blocks->block_new_size);
+ dap_chain_net_t *l_net = dap_chain_net_by_id(l_blocks->chain->net_id);
l_blocks->block_new->hdr.cell_id.uint64 = a_chain->cells->id.uint64;
l_blocks->block_new->hdr.chain_id.uint64 = l_blocks->chain->id.uint64;
}
diff --git a/modules/type/dag/CMakeLists.txt b/modules/type/dag/CMakeLists.txt
index d4912385dcf81e7f0630642cecb0109f70bf244a..f77a32ffac6a681c92b26e62e90c7dd84a6c9a45 100644
--- a/modules/type/dag/CMakeLists.txt
+++ b/modules/type/dag/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_cs_dag)
file(GLOB DAP_CHAIN_DAG_SRCS *.c)
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index e46648a74c18018bc198c1beeccfed11059353c6..6ca63a0cbd2448d3185ca5779091ac0185749ce3 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -203,6 +203,13 @@ int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
a_chain->callback_add_datums = s_chain_callback_datums_pool_proc;
+ // Datum operations callbacks
+/*
+ a_chain->callback_datum_iter_create = s_chain_callback_datum_iter_create; // Datum iterator create
+ a_chain->callback_datum_iter_delete = s_chain_callback_datum_iter_delete; // Datum iterator delete
+ a_chain->callback_datum_iter_get_first = s_chain_callback_datum_iter_get_first; // Get the fisrt datum from chain
+ a_chain->callback_datum_iter_get_next = s_chain_callback_datum_iter_get_next; // Get the next datum from chain from the current one
+*/
// Others
a_chain->_inheritor = l_dag;
@@ -291,21 +298,15 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
dap_chain_datum_t *l_datum = (dap_chain_datum_t*) dap_chain_cs_dag_event_get_datum(a_event_item->event, a_event_item->event_size);
pthread_rwlock_t * l_events_rwlock = &PVT(a_dag)->events_rwlock;
switch (l_datum->header.type_id) {
- case DAP_CHAIN_DATUM_256_TOKEN_DECL:
case DAP_CHAIN_DATUM_TOKEN_DECL: {
dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
return dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
}
break;
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
- // l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- // true : false;
- return dap_chain_ledger_token_emission_load(a_ledger, (dap_chain_datum_token_emission_t*) l_datum->data, l_datum->header.data_size);
+ return dap_chain_ledger_token_emission_load(a_ledger, l_datum->data, l_datum->header.data_size);
}
break;
- case DAP_CHAIN_DATUM_256_TX: // 256
case DAP_CHAIN_DATUM_TX: {
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
// don't save bad transactions to base
@@ -493,6 +494,7 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_add_from_treshold(dap_chain_t
*/
static size_t s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain_datum_t ** a_datums, size_t a_datums_count)
{
+
dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG(a_chain);
size_t l_datum_processed =0;
size_t l_events_round_new_size = 0;
@@ -523,7 +525,10 @@ static size_t s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain
// Verify for correctness
dap_chain_net_t * l_net = dap_chain_net_by_id( a_chain->net_id);
int l_verify_datum= dap_chain_net_verify_datum_for_add( l_net, l_datum) ;
- if (l_verify_datum != 0){
+ if (l_verify_datum != 0 &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_EMISSION &&
+ l_verify_datum != DAP_CHAIN_CS_VERIFY_CODE_TX_NO_TOKEN){
log_it(L_WARNING, "Datum doesn't pass verifications (code %d)",
l_verify_datum);
continue;
@@ -583,10 +588,9 @@ static size_t s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain
if (l_hashes_linked || s_seed_mode ) {
dap_chain_cs_dag_event_t * l_event = NULL;
size_t l_event_size = 0;
- if(l_dag->callback_cs_event_create) {
+ if(l_dag->callback_cs_event_create)
l_event = l_dag->callback_cs_event_create(l_dag,l_datum,l_hashes,l_hashes_linked,&l_event_size);
- }
- if ( l_event&&l_event_size){ // Event is created
+ if (l_event&&l_event_size) { // Event is created
if (l_dag->is_add_directy) {
l_cell = a_chain->cells;
if (s_chain_callback_atom_add(a_chain, l_event, l_event_size) == ATOM_ACCEPT) {
@@ -595,6 +599,7 @@ static size_t s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain
log_it(L_ERROR, "Can't add new event to the file '%s'", l_cell->file_storage_path);
continue;
}
+
// add all atoms from treshold
{
dap_chain_atom_ptr_t l_atom_treshold;
@@ -604,7 +609,7 @@ static size_t s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain
l_atom_treshold = s_chain_callback_atom_add_from_treshold(a_chain, &l_atom_treshold_size);
// add into file
if(l_atom_treshold) {
- int l_res = dap_chain_cell_file_append(a_chain->cells, l_atom_treshold, l_atom_treshold_size);
+ int l_res = dap_chain_cell_file_append(l_cell, l_atom_treshold, l_atom_treshold_size);
if(l_res < 0) {
log_it(L_ERROR, "Can't save event %p from treshold to the file '%s'",
l_atom_treshold, l_cell ? l_cell->file_storage_path : "[null]");
@@ -663,8 +668,9 @@ static size_t s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain
}
}
DAP_DELETE(l_hashes);
- if (l_cell)
+ if (l_cell) {
dap_chain_cell_close(l_cell);
+ }
dap_chain_global_db_objs_delete(l_events_round_new, l_events_round_new_size);
return l_datum_processed;
}
@@ -980,7 +986,7 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
* @param a_chain
* @return
*/
-static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id)
+static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id)
{
dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
l_atom_iter->chain = a_chain;
@@ -992,6 +998,7 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_
return l_atom_iter;
}
+
/**
* @brief s_chain_callback_atom_get_datum Get the datum from event
* @param a_atom_iter
@@ -1052,6 +1059,7 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_first(dap_chain_atom_
return a_atom_iter->cur;
}
+
/**
* @brief s_chain_callback_atom_iter_get_lasts
* @param a_atom_iter
@@ -1200,6 +1208,7 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_next( dap_chain_atom_
return a_atom_iter->cur;
}
+
/**
* @brief s_chain_callback_atom_iter_delete Delete dag event iterator
* @param a_atom_iter
diff --git a/modules/wallet/CMakeLists.txt b/modules/wallet/CMakeLists.txt
index 4d61a3b9f8bb7201f8ac88c5cc54a4549f817732..4feeb32d5872d7fa6d33d657452044dd6cb4376a 100644
--- a/modules/wallet/CMakeLists.txt
+++ b/modules/wallet/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.10)
project (dap_chain_wallet)
file(GLOB DAP_CHAIN_WALLET_SRCS *.c)
diff --git a/modules/wallet/dap_chain_wallet.c b/modules/wallet/dap_chain_wallet.c
index cd71a2ceff67e4d164b37a981f206167082efa5a..c8395ff5df541fba301e02648480d290b4af239a 100644
--- a/modules/wallet/dap_chain_wallet.c
+++ b/modules/wallet/dap_chain_wallet.c
@@ -427,12 +427,7 @@ uint256_t dap_chain_wallet_get_balance(dap_chain_wallet_t *a_wallet, dap_chain_n
{
dap_chain_net_t *l_net = dap_chain_net_by_id(a_net_id);
dap_chain_addr_t *l_addr =dap_chain_wallet_get_addr(a_wallet, a_net_id);
-// #ifdef DAP_GLOBAL_IS_INT128
-// uint128_t l_balance = 0;
-// #else
-// uint128_t l_balance = {};
-// #endif
- uint256_t l_balance = uint256_0;
+ uint256_t l_balance = {};
if (l_net)
{
dap_ledger_t *l_ledger = l_net->pub.ledger;