diff --git a/libdap-chain-mempool b/libdap-chain-mempool
deleted file mode 160000
index e58e40b46acd4b3ea5265000bfa8b64ddfc5f07e..0000000000000000000000000000000000000000
--- a/libdap-chain-mempool
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e58e40b46acd4b3ea5265000bfa8b64ddfc5f07e
diff --git a/libdap-chain-mempool/CMakeLists.txt b/libdap-chain-mempool/CMakeLists.txt
new file mode 100755
index 0000000000000000000000000000000000000000..5b64979025742cc8193d92468327aee6f77052ac
--- /dev/null
+++ b/libdap-chain-mempool/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.8)
+project (dap_chain_mempool)
+
+file(GLOB DAP_CHAIN_MEMPOOL_SRC *.c)
+file(GLOB DAP_CHAIN_MEMPOOL_HDR *.h)
+
+if(WIN32)
+ include_directories(../3rdparty/wepoll/)
+ include_directories(../3rdparty/uthash/src/)
+endif()
+
+add_library(${PROJECT_NAME} STATIC ${DAP_CHAIN_MEMPOOL_SRC} ${DAP_CHAIN_MEMPOOL_HDR})
+
+target_link_libraries(dap_chain_mempool dap_http_server dap_client dap_chain_net dap_chain_global_db dap_core)
+target_include_directories(dap_chain_mempool INTERFACE .)
+
+set(${PROJECT_NAME}_DEFINITIONS CACHE INTERNAL "${PROJECT_NAME}: Definitions" FORCE)
+
+set(${PROJECT_NAME}_INCLUDE_DIRS ${PROJECT_SOURCE_DIR} CACHE INTERNAL "${PROJECT_NAME}: Include Directories" FORCE)
diff --git a/libdap-chain-mempool/client_mempool.c b/libdap-chain-mempool/client_mempool.c
new file mode 100755
index 0000000000000000000000000000000000000000..9286fc8ae05c90edef5fdde4aa35e68de680b351
--- /dev/null
+++ b/libdap-chain-mempool/client_mempool.c
@@ -0,0 +1,334 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <gerasimov.dmitriy@demlabs.net>
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Kelvin Project https://github.com/kelvinblockchain
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include <errno.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#include <time.h>
+#include <pthread.h>
+#endif
+
+#include "dap_common.h"
+#include "dap_config.h"
+#include "dap_events.h"
+#include "dap_chain_node.h"
+#include "dap_client_pvt.h"
+//#include "dap_http_client_simple.h"
+#include "client_mempool.h"
+
+#define LOG_TAG "dap_client_mempool"
+
+static int listen_port_tcp = 8079;
+
+// send request to server
+static int client_mempool_send_request(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool,
+ const char *action, bool is_last_req);
+
+
+// callback for dap_client_new() in client_mempool_connect()
+static void stage_status_callback(dap_client_t *a_client, void *a_arg)
+{
+ //printf("* stage_status_callback client=%x data=%x\n", a_client, a_arg);
+}
+// callback for dap_client_new() in client_mempool_connect()
+static void stage_status_error_callback(dap_client_t *a_client, void *a_arg)
+{
+ //printf("* tage_status_error_callback client=%x data=%x\n", a_client, a_arg);
+}
+
+// callback for dap_client_request_enc() in client_mempool_send_datum()
+static void a_response_proc(dap_client_t *a_client, void *str, size_t str_len)
+{
+ //printf("a* _response_proc a_client=%x str=%s str_len=%d\n", a_client, str, str_len);
+ client_mempool_t *mempool = a_client->_inheritor;
+ assert(mempool);
+ if(mempool) {
+ if(str_len > 0) {
+ mempool->read_data_t.data = DAP_NEW_Z_SIZE(uint8_t, str_len + 1);
+ if(mempool->read_data_t.data) {
+ memcpy(mempool->read_data_t.data, str, str_len);
+ mempool->read_data_t.data_len = str_len;
+ }
+ }
+ pthread_mutex_lock(&mempool->wait_mutex);
+ mempool->state = CLIENT_MEMPOOL_SENDED;
+
+#ifndef _WIN32
+ pthread_cond_signal(&mempool->wait_cond);
+#else
+ SetEvent( mempool->wait_cond );
+#endif
+
+ pthread_mutex_unlock(&mempool->wait_mutex);
+ }
+}
+
+// callback for dap_client_request_enc() in client_mempool_send_datum()
+static void a_response_error(dap_client_t *a_client, int val)
+{
+ //printf("* a_response_error a_client=%x val=%d\n", a_client, val);
+ client_mempool_t *mempool = a_client->_inheritor;
+ assert(mempool);
+ if(mempool) {
+ pthread_mutex_lock(&mempool->wait_mutex);
+ mempool->state = CLIENT_MEMPOOL_ERROR;
+#ifndef _WIN32
+ pthread_cond_signal(&mempool->wait_cond);
+#else
+ SetEvent( mempool->wait_cond );
+#endif
+ pthread_mutex_unlock(&mempool->wait_mutex);
+ }
+}
+
+// callback for the end of handshake in dap_client_go_stage() / client_mempool_connect()
+static void a_stage_end_callback(dap_client_t *a_client, void *a_arg)
+{
+ client_mempool_t *mempool = a_client->_inheritor;
+ assert(mempool);
+ if(mempool) {
+ pthread_mutex_lock(&mempool->wait_mutex);
+ mempool->state = CLIENT_MEMPOOL_CONNECTED;
+#ifndef _WIN32
+ pthread_cond_signal(&mempool->wait_cond);
+#else
+ SetEvent( mempool->wait_cond );
+#endif
+ pthread_mutex_unlock(&mempool->wait_mutex);
+ }
+}
+
+int client_mempool_init(void)
+{
+ listen_port_tcp = dap_config_get_item_int32_default(g_config, "server", "listen_port_tcp", 8079);
+ return 0;
+}
+
+void client_mempool_deinit()
+{
+ //dap_http_client_simple_deinit();
+ dap_client_deinit();
+}
+
+client_mempool_t *client_mempool_connect(const char *addr)
+{
+ if(!addr || strlen(addr) < 1)
+ return NULL;
+ client_mempool_t *mempool = DAP_NEW_Z(client_mempool_t);
+ mempool->state = CLIENT_MEMPOOL_INIT;
+
+ log_it(L_NOTICE, "======= client_mempool_connect( )" );
+
+#ifndef _WIN32
+ pthread_condattr_t attr;
+ pthread_condattr_init(&attr);
+ pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
+ pthread_cond_init(&mempool->wait_cond, &attr);
+#else
+ mempool->wait_cond = CreateEventA( NULL, FALSE, FALSE, NULL );
+#endif
+
+ pthread_mutex_init(&mempool->wait_mutex, NULL);
+ mempool->a_events = dap_events_new();
+ mempool->a_client = dap_client_new(mempool->a_events, stage_status_callback, stage_status_error_callback);
+ mempool->a_client->_inheritor = mempool;
+ dap_client_pvt_t *l_client_internal = DAP_CLIENT_PVT(mempool->a_client);
+
+ l_client_internal->uplink_addr = strdup(addr);
+ l_client_internal->uplink_port = listen_port_tcp; // reads from settings, default 8079
+ l_client_internal->uplink_protocol_version = DAP_PROTOCOL_VERSION;
+ dap_client_stage_t a_stage_target = STAGE_ENC_INIT;
+
+ mempool->state = CLIENT_MEMPOOL_CONNECT;
+ // Handshake
+ dap_client_go_stage(mempool->a_client, a_stage_target, a_stage_end_callback);
+ return mempool;
+}
+
+/**
+ * wait for the complete of request
+ *
+ * timeout_ms timeout in milliseconds
+ * waited_state state which we will wait, sample CLIENT_MEMPOOL_CONNECTED or CLIENT_MEMPOOL_SENDED
+ * return -1 false, 0 timeout, 1 end of connection or sending data
+ */
+int client_mempool_wait(client_mempool_t *mempool, int waited_state, int timeout_ms)
+{
+ int ret = -1;
+ if( !mempool )
+ return -1;
+
+ log_it(L_NOTICE, "======= client_mempool_wait( ) tm %u ms", timeout_ms );
+
+ pthread_mutex_lock(&mempool->wait_mutex);
+// have waited
+ if(mempool->state == waited_state) {
+ pthread_mutex_unlock(&mempool->wait_mutex);
+ return 1;
+ }
+// prepare for signal waiting
+#ifndef _WIN32
+ struct timespec to;
+ clock_gettime(CLOCK_MONOTONIC, &to);
+ int64_t nsec_new = to.tv_nsec + timeout_ms * 1000000ll;
+// if the new number of nanoseconds is more than a second
+ if(nsec_new > (long) 1e9) {
+ to.tv_sec += nsec_new / (long) 1e9;
+ to.tv_nsec = nsec_new % (long) 1e9;
+ }
+ else
+ to.tv_nsec = (long) nsec_new;
+// signal waiting
+ int wait = pthread_cond_timedwait(&mempool->wait_cond, &mempool->wait_mutex, &to);
+ if(wait == 0) //0
+ ret = 1;
+ else if(wait == ETIMEDOUT) // 110 260
+ ret = 0;
+#else
+ int wait = WaitForSingleObject( mempool->wait_cond, (uint32_t)timeout_ms );
+ pthread_mutex_lock(&mempool->wait_mutex);
+
+ if ( wait == WAIT_OBJECT_0 ) return 1;
+ else if ( wait == WAIT_TIMEOUT || wait == WAIT_FAILED ) {
+ ret = 0;
+ }
+#endif
+
+ pthread_mutex_unlock(&mempool->wait_mutex);
+ return ret;
+}
+
+/**
+ * get read data from server
+ */
+uint8_t* client_mempool_read(client_mempool_t *mempool, int *data_len)
+{
+ if(mempool && mempool->read_data_t.data_len > 0) {
+
+ uint8_t*data = DAP_NEW_Z_SIZE(uint8_t, mempool->read_data_t.data_len + 1);
+ if(mempool->read_data_t.data) {
+ memcpy(data, mempool->read_data_t.data, mempool->read_data_t.data_len);
+ if(data_len)
+ *data_len = mempool->read_data_t.data_len;
+ return data;
+ }
+ }
+ return NULL;
+}
+
+void client_mempool_close(client_mempool_t *mempool)
+{
+ if(mempool) {
+ // send last request for dehandshake with "SessionCloseAfterRequest=true"
+ client_mempool_send_request(mempool, NULL, 0, true);
+ // wait close session
+ client_mempool_wait(mempool, CLIENT_MEMPOOL_SENDED, 500);
+ // clean mempool
+ dap_client_pvt_t *l_client_internal = DAP_CLIENT_PVT(mempool->a_client);
+ DAP_DELETE(l_client_internal->uplink_addr);
+ dap_client_delete(mempool->a_client);
+ dap_events_delete(mempool->a_events);
+ DAP_DELETE(mempool->read_data_t.data);
+ pthread_cond_destroy(&mempool->wait_cond);
+ pthread_mutex_destroy(&mempool->wait_mutex);
+ DAP_DELETE(mempool);
+ }
+}
+
+// set new state and delete previous read data
+static void client_mempool_reset(client_mempool_t *mempool, int new_state)
+{
+ if(!mempool)
+ return;
+ pthread_mutex_lock(&mempool->wait_mutex);
+ mempool->read_data_t.data_len = 0;
+ DAP_DELETE(mempool->read_data_t.data);
+ mempool->read_data_t.data = NULL;
+ mempool->state = new_state;
+ pthread_mutex_unlock(&mempool->wait_mutex);
+}
+
+// send request to server
+static int client_mempool_send_request(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool,
+ const char *action, bool is_last_req)
+{
+ if(!mempool || mempool->state < CLIENT_MEMPOOL_CONNECTED)
+ return -1;
+ const char * a_path = "mempool";
+ const char *a_suburl = (action) ? action : "close";
+ const char* a_query = NULL;
+ size_t a_request_size = 1;
+ uint8_t *a_request = (datum_mempool) ? dap_datum_mempool_serialize(datum_mempool, &a_request_size) : (uint8_t*) " ";
+ uint8_t *a_request_out = DAP_NEW_Z_SIZE(uint8_t, a_request_size * 2); // a_request + 1 byte for type action
+ dap_bin2hex(a_request_out, a_request, a_request_size);
+ client_mempool_reset(mempool, CLIENT_MEMPOOL_SEND);
+ dap_client_pvt_t * l_client_internal = DAP_CLIENT_PVT(mempool->a_client);
+ l_client_internal->is_close_session = is_last_req;
+ dap_client_request_enc(mempool->a_client, a_path, a_suburl, a_query, a_request_out, a_request_size * 2,
+ a_response_proc, a_response_error);
+ if(datum_mempool)
+ DAP_DELETE(a_request);
+ DAP_DELETE(a_request_out);
+ return 1;
+}
+
+/**
+ * datum add in mempool
+ *
+ * return -1 not connected or error, 1 send packet OK
+ */
+int client_mempool_send_datum(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool)
+{
+ return client_mempool_send_request(mempool, datum_mempool, "add", false);
+}
+
+/**
+ * datum check in mempool
+ *
+ * return -1 not connected or error, 1 send packet OK
+ */
+int client_mempool_check_datum(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool)
+{
+ return client_mempool_send_request(mempool, datum_mempool, "check", false);
+}
+
+/**
+ * datum delete from mempool
+ *
+ * return -1 not connected or error, 1 send packet OK
+ */
+int client_mempool_del_datum(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool)
+{
+ return client_mempool_send_request(mempool, datum_mempool, "del", false);
+}
diff --git a/libdap-chain-mempool/client_mempool.h b/libdap-chain-mempool/client_mempool.h
new file mode 100755
index 0000000000000000000000000000000000000000..475a02a396d11bebc526a26d1c0dab95461c756c
--- /dev/null
+++ b/libdap-chain-mempool/client_mempool.h
@@ -0,0 +1,84 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <gerasimov.dmitriy@demlabs.net>
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Kelvin Project https://github.com/kelvinblockchain
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include <pthread.h>
+#include <stdbool.h>
+#include "dap_client.h"
+#include "dap_chain_mempool.h"
+
+// connection states
+enum {
+ CLIENT_MEMPOOL_ERROR = -1,
+ CLIENT_MEMPOOL_INIT,
+ CLIENT_MEMPOOL_CONNECT,
+ CLIENT_MEMPOOL_CONNECTED,
+ CLIENT_MEMPOOL_SEND,
+ CLIENT_MEMPOOL_SENDED,
+ CLIENT_MEMPOOL_END
+};
+
+// state for a client connection with mempool
+typedef struct client_mempool {
+ int state;
+ dap_events_t *a_events;
+ dap_client_t *a_client;
+ pthread_cond_t wait_cond;
+ pthread_mutex_t wait_mutex;
+ struct readed_data{
+ uint8_t *data;
+ int data_len;
+ }read_data_t;
+} client_mempool_t;
+
+int client_mempool_init(void);
+void client_mempool_deinit();
+
+client_mempool_t* client_mempool_connect(const char *addr);
+void client_mempool_close(client_mempool_t *mempool);
+
+/**
+ * timeout_ms timeout in milliseconds
+ * return -1 false, 0 timeout, 1 end of connection or sending data
+ */
+int client_mempool_wait(client_mempool_t *mempool, int waited_state, int timeout_ms);
+
+/**
+ * get read data from server
+ */
+uint8_t* client_mempool_read(client_mempool_t *mempool, int *data_len);
+
+/**
+ * datum add in mempool
+ */
+int client_mempool_send_datum(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool);
+/**
+ * datum check in mempool
+ */
+int client_mempool_check_datum(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool);
+/**
+ * datum delete from mempool
+ */
+int client_mempool_del_datum(client_mempool_t *mempool, dap_datum_mempool_t *datum_mempool);
diff --git a/libdap-chain-mempool/dap_chain_mempool.c b/libdap-chain-mempool/dap_chain_mempool.c
new file mode 100755
index 0000000000000000000000000000000000000000..528ecf06c165a8f7b6f3ce7e60ed5bea601c07b8
--- /dev/null
+++ b/libdap-chain-mempool/dap_chain_mempool.c
@@ -0,0 +1,1112 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <gerasimov.dmitriy@demlabs.net>
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Kelvin Project https://github.com/kelvinblockchain
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <memory.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#include <time.h>
+#include <pthread.h>
+#endif
+
+#include "dap_common.h"
+#include "dap_hash.h"
+#include "dap_http_client.h"
+#include "dap_http_simple.h"
+//#include "dap_enc_http.h"
+#include "dap_enc_http.h"
+//#include "dap_http.h"
+#include "http_status_code.h"
+#include "dap_chain_common.h"
+#include "dap_chain_node.h"
+#include "dap_chain_global_db.h"
+#include "dap_enc.h"
+#include <dap_enc_http.h>
+#include <dap_enc_key.h>
+#include <dap_enc_ks.h>
+#include "dap_chain_mempool.h"
+
+#include "dap_common.h"
+#include "dap_list.h"
+#include "dap_chain.h"
+#include "dap_chain_net.h"
+#include "dap_sign.h"
+#include "dap_chain_datum_tx.h"
+#include "dap_chain_datum_tx_items.h"
+
+#define LOG_TAG "dap_chain_mempool"
+
+typedef struct list_used_item {
+ dap_chain_hash_fast_t tx_hash_fast;
+ int num_idx_out;
+ uint8_t padding[4];
+ uint64_t value;
+//dap_chain_tx_out_t *tx_out;
+} list_used_item_t;
+
+
+int dap_datum_mempool_init(void)
+{
+ return 0;
+}
+
+/**
+ * @brief dap_chain_mempool_datum_add
+ * @param a_datum
+ * @return
+ */
+int dap_chain_mempool_datum_add(dap_chain_datum_t * a_datum, dap_chain_t * a_chain )
+{
+ if( a_datum == NULL){
+ log_it(L_ERROR, "NULL datum trying to add in mempool");
+ return -1;
+ }
+ int ret =0;
+
+ dap_chain_hash_fast_t l_key_hash;
+ dap_hash_fast(a_datum->data , a_datum->header.data_size, &l_key_hash);
+
+ char * l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
+ char * l_gdb_group = dap_chain_net_get_gdb_group_mempool(a_chain);
+ if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (byte_t *) a_datum, dap_chain_datum_size(a_datum)
+ ,l_gdb_group)) {
+ log_it(L_NOTICE, "Datum with data's hash %s was placed in mempool", l_key_str);
+ }else{
+ log_it(L_WARNING, "Can't place data's hash %s was placed in mempool", l_key_str);
+ }
+ DAP_DELETE(l_gdb_group);
+ DAP_DELETE(l_key_str);
+ return ret;
+}
+
+/**
+ * Make transfer transaction & insert to cache
+ *
+ * return 0 Ok, -2 not enough funds to transfer, -1 other Error
+ */
+int dap_chain_mempool_tx_create(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)
+{
+ // 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)
+ return -1;
+
+ // find the transactions from which to take away coins
+ dap_list_t *l_list_used_out = NULL; // list of transaction with 'out' items
+ uint64_t l_value_transfer = 0; // how many coins to transfer
+ {
+ dap_chain_hash_fast_t l_tx_cur_hash = { 0 };
+ uint64_t l_value_need = a_value + a_value_fee;
+ while(l_value_transfer < l_value_need)
+ {
+ // 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_chain->ledger,a_token_ticker, a_addr_from,
+ &l_tx_cur_hash);
+ if(!l_tx)
+ break;
+ // Get all item from transaction by type
+ int l_item_count = 0;
+ dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get( l_tx, TX_ITEM_TYPE_OUT,
+ &l_item_count);
+ dap_list_t *l_list_tmp = l_list_out_items;
+ int l_out_idx_tmp = 0; // current index of 'out' item
+ while(l_list_tmp) {
+ dap_chain_tx_out_t *out_item = l_list_tmp->data;
+ // if 'out' item has addr = a_addr_from
+ if(out_item && !memcmp(a_addr_from, &out_item->addr, sizeof(dap_chain_addr_t))) {
+
+ // Check whether used 'out' items
+ if(!dap_chain_ledger_tx_hash_is_used_out_item (a_chain->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 = out_item->header.value;
+ l_list_used_out = dap_list_append(l_list_used_out, item);
+ l_value_transfer += item->value;
+ // already accumulated the required value, finish the search for 'out' items
+ if(l_value_transfer >= l_value_need) {
+ break;
+ }
+ }
+ }
+ // go to the next 'out' item in l_tx transaction
+ l_out_idx_tmp++;
+ l_list_tmp = dap_list_next(l_list_tmp);
+ }
+ dap_list_free(l_list_out_items);
+ }
+
+ // nothing to tranfer (not enough funds)
+ if(!l_list_used_out || l_value_transfer < l_value_need) {
+ dap_list_free_full(l_list_used_out, free);
+ return -2;
+ }
+ }
+
+ // create empty transaction
+ dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
+ // add 'in' items
+ {
+ dap_list_t *l_list_tmp = l_list_used_out;
+ uint64_t l_value_to_items = 0; // 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(&l_tx, &item->tx_hash_fast,(uint32_t) item->num_idx_out) == 1) {
+ l_value_to_items += item->value;
+ }
+ l_list_tmp = dap_list_next(l_list_tmp);
+ }
+ assert(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
+ if(dap_chain_datum_tx_add_out_item(&l_tx, a_addr_to, a_value) == 1) {
+ l_value_pack += a_value;
+ // 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;
+ }
+ }
+ // coin back
+ uint64_t l_value_back = l_value_transfer - l_value_pack;
+ if(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 -1;
+ }
+ }
+ }
+
+ // add 'sign' items
+ if(dap_chain_datum_tx_add_sign_item(&l_tx, a_key_from) != 1) {
+ dap_chain_datum_tx_delete(l_tx);
+ return -1;
+ }
+
+ size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
+ dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size);
+ DAP_DELETE(l_tx);
+ if(dap_chain_mempool_datum_add (l_datum, a_chain) == 0){
+ return 0;
+ }else{
+ DAP_DELETE( l_datum );
+ return -4;
+ }
+}
+
+/**
+ * Make transfer transaction & insert to cache
+ *
+ * return 0 Ok, -2 not enough funds to transfer, -1 other Error
+ */
+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[10],
+ uint64_t a_value, uint64_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){
+ 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) );
+
+
+
+ // Search unused out:
+ uint64_t l_value_need =a_tx_num*( a_value + a_value_fee );
+ dap_chain_hash_fast_t l_tx_prev_hash = { 0 };
+ dap_list_t *l_list_used_out = NULL; // list of transaction with 'out' items
+ uint64_t l_value_transfer = 0; // how many coins to transfer
+
+ log_it(L_DEBUG,"Create %lu transactions, summary %Lf.7", a_tx_num,dap_chain_balance_to_coins(l_value_need) ) ;
+
+ while(l_value_transfer < l_value_need){
+ // 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_chain->ledger, a_token_ticker,a_addr_from,
+ &l_tx_prev_hash);
+ if(!l_tx)
+ break;
+ // Get all item from transaction by type
+ int l_item_count = 0;
+ dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get( l_tx, TX_ITEM_TYPE_OUT,
+ &l_item_count);
+ dap_list_t *l_list_tmp = l_list_out_items;
+ int l_out_idx_tmp = 0; // current index of 'out' item
+ while(l_list_tmp) {
+ dap_chain_tx_out_t *out_item = l_list_tmp->data;
+ // if 'out' item has addr = a_addr_from
+ if(out_item && out_item->header.value && !memcmp(a_addr_from, &out_item->addr, sizeof(dap_chain_addr_t))) {
+
+ // Check whether used 'out' items
+ if(!dap_chain_ledger_tx_hash_is_used_out_item (a_chain->ledger, &l_tx_prev_hash, l_out_idx_tmp)) {
+
+ list_used_item_t *l_it = DAP_NEW(list_used_item_t);
+ memcpy(&l_it->tx_hash_fast, &l_tx_prev_hash, sizeof(dap_chain_hash_fast_t));
+ l_it->num_idx_out = l_out_idx_tmp;
+ l_it->value = out_item->header.value;
+ log_it(L_DEBUG," Found output with value %llu", l_it->value );
+ l_list_used_out = dap_list_append(l_list_used_out, l_it);
+ l_value_transfer += l_it->value;
+ // already accumulated the required value, finish the search for 'out' items
+ if(l_value_transfer >= l_value_need) {
+ l_out_idx_tmp++;
+ break;
+ }
+ }
+ }
+ // go to the next 'out' item in l_tx transaction
+ l_out_idx_tmp++;
+ l_list_tmp = dap_list_next(l_list_tmp);
+ }
+ }
+
+ // nothing to tranfer (not enough funds)
+ if(!l_list_used_out || l_value_transfer < l_value_need) {
+ log_it(L_WARNING,"Not enough funds to transfer");
+ dap_list_free_full(l_list_used_out, free);
+ return -2;
+ }
+
+ for (size_t i=0; i< a_tx_num ; i++){
+ log_it(L_DEBUG, "Prepare tx %u",i);
+ // find the transactions from which to take away coins
+
+ // create empty transaction
+ dap_chain_datum_tx_t *l_tx_new = dap_chain_datum_tx_create();
+ uint64_t l_value_back=0;
+ // 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
+
+ // Add in and remove out used items
+ while(l_list_tmp) {
+ list_used_item_t *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) );
+
+ 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 %llu datoshi",l_in_hash_str, item->value);
+ }else{
+ log_it(L_WARNING,"Can't add input from %s with %llu datoshi",l_in_hash_str, 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 )
+ break;
+ }
+ if ( l_value_to_items < (a_value + a_value_fee) ){
+ log_it(L_ERROR,"Not enought values on output %llu to produce enought ins %llu when need %llu",
+ l_value_to_items, l_value_transfer,
+ l_value_need);
+ return -5;
+ }
+
+ // add 'out' items
+ uint64_t l_value_pack = 0; // 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;
+ // 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;
+ }
+ }
+ // coin back
+ l_value_back = l_value_transfer - l_value_pack;
+ if(l_value_back) {
+ //log_it(L_DEBUG,"Change back %llu", 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);
+ return -3;
+ }
+ }
+
+ // add 'sign' items
+ if(dap_chain_datum_tx_add_sign_item(&l_tx_new, a_key_from) != 1) {
+ dap_chain_datum_tx_delete(l_tx_new);
+ return -1;
+ }
+ // now tx is formed - calc size and hash
+ size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx_new);
+
+ 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) {
+ //log_it(L_DEBUG,"We have value back %llu 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,
+ &l_item_count);
+ dap_list_t *l_list_tmp = l_list_out_items;
+ int l_out_idx_tmp = 0; // current index of 'out' item
+ //log_it(L_DEBUG,"We have %d outputs in new TX", l_item_count);
+ while(l_list_tmp) {
+ dap_chain_tx_out_t * l_out = l_list_tmp->data ;
+ if( ! l_out){
+ log_it(L_WARNING, "Output is NULL, continue check outputs...");
+ l_out_idx_tmp++;
+ continue;
+ }
+ if ( memcmp(&l_out->addr, a_addr_from, sizeof (*a_addr_from))==0 ){
+ list_used_item_t *l_item_back = DAP_NEW(list_used_item_t);
+ memcpy(&l_item_back->tx_hash_fast, &l_tx_new_hash, sizeof(dap_chain_hash_fast_t));
+ l_item_back->num_idx_out = l_out_idx_tmp;
+ l_item_back->value = l_value_back;
+ l_list_used_out = dap_list_prepend(l_list_used_out, l_item_back);
+ log_it(L_DEBUG,"Found change back output, stored back in UTXO table");
+ break;
+ }
+ l_list_tmp = l_list_tmp->next;
+ l_out_idx_tmp++;
+ }
+ //log_it(L_DEBUG,"Checked all outputs");
+ dap_list_free( l_list_out_items);
+ }
+ l_value_transfer -= l_value_pack;
+
+ // Now produce datum
+ dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx_new, l_tx_size);
+
+ dap_chain_datum_tx_delete(l_tx_new);
+ //dap_chain_ledger_tx_add( a_chain->ledger, l_tx);
+
+ 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_len = l_tx_size + sizeof(l_datum->header);
+ log_it(L_DEBUG, "Prepared obj with key %s (value_len = %llu)",
+ l_objs[i].key? l_objs[i].key :"NULL" , l_objs[i].value_len );
+
+ }
+ dap_list_free_full(l_list_used_out, free);
+
+ char * l_gdb_group = dap_chain_net_get_gdb_group_mempool(a_chain);
+
+ //return 0;
+ if( dap_chain_global_db_gr_save(l_objs,a_tx_num,l_gdb_group) ) {
+ log_it(L_NOTICE, "%u transaction are placed in mempool", a_tx_num);
+ //DAP_DELETE(l_objs);
+ DAP_DELETE(l_gdb_group);
+ return 0;
+ }else{
+ log_it(L_ERROR, "Can't place %u transactions in mempool", a_tx_num);
+ //DAP_DELETE(l_objs);
+ DAP_DELETE(l_gdb_group);
+ return -4;
+ }
+
+
+}
+
+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)
+{
+ dap_ledger_t * l_ledger = a_net ? dap_chain_ledger_by_net_name( a_net->pub.name ) : NULL;
+ if ( ! a_net || ! l_ledger || ! a_addr_to )
+ return NULL;
+ if ( ! dap_chain_addr_check_sum (a_addr_to) ){
+ log_it(L_ERROR, "Wrong address_to checksum");
+ return NULL;
+ }
+
+ // create empty transaction
+ dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
+
+ uint16_t pos=0;
+ dap_chain_datum_tx_add_item(&l_tx, (byte_t*) l_receipt);
+ pos++;
+ // add 'in_cond' items
+ // TODO - find first cond_item occurance, not just set it to 1
+ if (dap_chain_datum_tx_add_in_cond_item(&l_tx,a_tx_prev_hash,1,pos-1) != 0 ){
+ dap_chain_datum_tx_delete(l_tx);
+ log_it( L_ERROR, "Cant add tx cond input");
+ return NULL;
+ }
+
+ if(dap_chain_datum_tx_add_out_item(&l_tx, a_addr_to, l_receipt->receipt_info.value_datoshi) != 1) {
+ dap_chain_datum_tx_delete(l_tx);
+ log_it( L_ERROR, "Cant add tx output");
+ return NULL;
+ }
+
+ // add 'sign' items
+ if (l_key_tx_sign){
+ if(dap_chain_datum_tx_add_sign_item(&l_tx, l_key_tx_sign) != 1) {
+ dap_chain_datum_tx_delete(l_tx);
+ log_it( L_ERROR, "Can't add sign output");
+ return NULL;
+ }
+ }
+ size_t l_tx_size = dap_chain_datum_tx_get_size( l_tx );
+ dap_chain_datum_t *l_datum = dap_chain_datum_create( DAP_CHAIN_DATUM_TX, l_tx, l_tx_size );
+
+ dap_chain_hash_fast_t *l_key_hash = DAP_NEW_Z( dap_chain_hash_fast_t );
+ dap_hash_fast( l_tx, l_tx_size, l_key_hash );
+ DAP_DELETE( l_tx );
+
+ char * l_key_str = dap_chain_hash_fast_to_str_new( l_key_hash );
+ char * l_gdb_group = dap_chain_net_get_gdb_group_mempool_by_chain_type( a_net ,CHAIN_TYPE_TX);
+ if( dap_chain_global_db_gr_set( dap_strdup(l_key_str), (uint8_t *) l_datum, dap_chain_datum_size(l_datum)
+ , l_gdb_group ) ) {
+ log_it(L_NOTICE, "Transaction %s placed in mempool", l_key_str);
+ }
+ DAP_DELETE(l_gdb_group);
+ DAP_DELETE(l_key_str);
+
+ return l_key_hash;
+}
+
+
+/**
+ * Make transfer transaction
+ *
+ * return dap_chain_datum_t, NULL if Error
+ */
+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)
+{
+ 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)
+ return NULL;
+
+ // find the transactions from which to take away coins
+ dap_list_t *l_list_used_out = NULL; // list of transaction with 'out' items
+ uint64_t l_value_transfer = 0; // how many coins to transfer
+ {
+ dap_chain_hash_fast_t l_tx_cur_hash = { 0 };
+ uint64_t l_value_need = a_value + a_value_fee;
+ while(l_value_transfer < l_value_need)
+ {
+ // 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(l_ledger, a_token_ticker,a_addr_from,
+ &l_tx_cur_hash);
+ if(!l_tx)
+ break;
+ // Get all item from transaction by type
+ int l_item_count = 0;
+ dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get( l_tx, TX_ITEM_TYPE_OUT,
+ &l_item_count);
+ dap_list_t *l_list_tmp = l_list_out_items;
+ int l_out_idx_tmp = 0; // current index of 'out' item
+ while(l_list_tmp) {
+ dap_chain_tx_out_t *out_item = l_list_tmp->data;
+ // if 'out' item has addr = a_addr_from
+ if(out_item && !memcmp(a_addr_from, &out_item->addr, sizeof(dap_chain_addr_t))) {
+
+ // Check whether used 'out' items
+ if(!dap_chain_ledger_tx_hash_is_used_out_item(l_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 = out_item->header.value;
+ l_list_used_out = dap_list_append(l_list_used_out, item);
+ l_value_transfer += item->value;
+ // already accumulated the required value, finish the search for 'out' items
+ if(l_value_transfer >= l_value_need) {
+ break;
+ }
+ }
+ }
+ // go to the next 'out' item in l_tx transaction
+ l_out_idx_tmp++;
+ l_list_tmp = dap_list_next(l_list_tmp);
+ }
+ dap_list_free(l_list_out_items);
+ }
+
+ // nothing to tranfer (not enough funds)
+ if(!l_list_used_out || l_value_transfer < l_value_need) {
+ dap_list_free_full(l_list_used_out, free);
+ log_it( L_ERROR, "nothing to tranfer (not enough funds)");
+ return NULL;
+ }
+ }
+
+ // create empty transaction
+ dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
+ // 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
+ while(l_list_tmp) {
+ list_used_item_t *item = l_list_tmp->data;
+ if(dap_chain_datum_tx_add_in_item(&l_tx, &item->tx_hash_fast,(uint32_t) item->num_idx_out) == 1) {
+ l_value_to_items += item->value;
+ }
+ l_list_tmp = dap_list_next(l_list_tmp);
+ }
+ assert(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
+ 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;
+ // transaction fee
+ if(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) {
+ 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");
+ return NULL;
+ }
+ }
+ }
+
+ // add 'sign' items
+ if(dap_chain_datum_tx_add_sign_item(&l_tx, a_key_from) != 1) {
+ dap_chain_datum_tx_delete(l_tx);
+ log_it( L_ERROR, "Can't add sign output");
+ return NULL;
+ }
+
+ size_t l_tx_size = dap_chain_datum_tx_get_size( l_tx );
+ dap_chain_datum_t *l_datum = dap_chain_datum_create( DAP_CHAIN_DATUM_TX, l_tx, l_tx_size );
+
+ return l_datum;
+ /*dap_chain_hash_fast_t *l_key_hash = DAP_NEW_Z( dap_chain_hash_fast_t );
+ dap_hash_fast( l_tx, l_tx_size, l_key_hash );
+ DAP_DELETE( l_tx );
+
+ char * l_key_str = dap_chain_hash_fast_to_str_new( l_key_hash );
+ char * l_gdb_group = dap_chain_net_get_gdb_group_mempool_by_chain_type( a_net ,CHAIN_TYPE_TX);
+ if( dap_chain_global_db_gr_set( dap_strdup(l_key_str), (uint8_t *) l_datum, dap_chain_datum_size(l_datum)
+ , l_gdb_group ) ) {
+ log_it(L_NOTICE, "Transaction %s placed in mempool", l_key_str);
+ }
+ DAP_DELETE(l_gdb_group);
+ DAP_DELETE(l_key_str);
+
+ return l_key_hash;*/
+}
+
+/**
+ * Make transfer transaction & insert to database
+ *
+ * return 0 Ok, -2 not enough funds to transfer, -1 other Error
+ */
+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)
+{
+
+ dap_chain_t *l_chain = dap_chain_net_get_chain_by_chain_type(a_net, CHAIN_TYPE_TX);
+ if(!l_chain)
+ 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);
+
+ if(!l_datum)
+ return NULL;
+ size_t l_datums_number = l_chain->callback_datums_pool_proc(l_chain, &l_datum, 1);
+ if(!l_datums_number)
+ return NULL;
+
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)&(l_datum->data);
+ size_t l_tx_size = l_datum->header.data_size;
+
+ dap_chain_hash_fast_t *l_key_hash = DAP_NEW_Z( dap_chain_hash_fast_t );
+ dap_hash_fast( l_tx, l_tx_size, l_key_hash );
+ //DAP_DELETE( l_tx );
+
+ return l_key_hash;
+}
+
+/**
+ * Make transfer transaction & insert to cache
+ *
+ * return 0 Ok, -2 not enough funds to transfer, -1 other Error
+ */
+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)
+{
+ // 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);
+
+ if(!l_datum)
+ return NULL;
+
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)&(l_datum->data);
+ size_t l_tx_size = l_datum->header.data_size;//dap_chain_datum_tx_get_size( l_tx );
+
+ dap_chain_hash_fast_t *l_key_hash = DAP_NEW_Z( dap_chain_hash_fast_t );
+ dap_hash_fast( l_tx, l_tx_size, l_key_hash );
+ //DAP_DELETE( l_tx );
+
+ char * l_key_str = dap_chain_hash_fast_to_str_new( l_key_hash );
+ char * l_gdb_group = dap_chain_net_get_gdb_group_mempool_by_chain_type( a_net ,CHAIN_TYPE_TX);
+ if( dap_chain_global_db_gr_set( dap_strdup(l_key_str), (uint8_t *) l_datum, dap_chain_datum_size(l_datum)
+ , l_gdb_group ) ) {
+ log_it(L_NOTICE, "Transaction %s placed in mempool", l_key_str);
+ }
+ DAP_DELETE(l_gdb_group);
+ DAP_DELETE(l_key_str);
+
+ return l_key_hash;
+}
+
+/**
+ * Make receipt transaction & insert to cache
+ *
+ * return 0 Ok, -2 not enough funds to transfer, -1 other Error
+ */
+int dap_chain_mempool_tx_create_receipt(uint64_t a_value)
+//(dap_enc_key_t *a_key_from, dap_enc_key_t *a_key_cond,
+// const dap_chain_addr_t* a_addr_from, const dap_chain_addr_t* a_addr_cond,
+// 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, const void *a_cond, size_t a_cond_size)
+{
+ // check valid param
+/* if(!a_key_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_cond) ||
+ (a_addr_fee && !dap_chain_addr_check_sum(a_addr_fee)) || !a_value)
+ return -1;*/
+/*
+ // find the transactions from which to take away coins
+ dap_list_t *l_list_used_out = NULL; // list of transaction with 'out' items
+ uint64_t l_value_transfer = 0; // how many coins to transfer
+ {
+ dap_chain_hash_fast_t l_tx_cur_hash = { 0 };
+ uint64_t l_value_need = a_value + a_value_fee;
+ while(l_value_transfer < l_value_need)
+ {
+ // Get the transaction in the cache by the addr in out item
+ const dap_chain_datum_tx_t *l_tx = dap_chain_ledger_tx_find_by_addr(a_addr_from,
+ &l_tx_cur_hash);
+ if(!l_tx)
+ break;
+ // Get all item from transaction by type
+ int l_item_count = 0;
+ dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) l_tx, TX_ITEM_TYPE_OUT,
+ &l_item_count);
+ dap_list_t *l_list_tmp = l_list_out_items;
+ int l_out_idx_tmp = 0; // current index of 'out' item
+ while(l_list_tmp) {
+ dap_chain_tx_out_t *out_item = l_list_tmp->data;
+ // if 'out' item has addr = a_addr_from
+ if(out_item && &out_item->addr && !memcmp(a_addr_from, &out_item->addr, sizeof(dap_chain_addr_t))) {
+
+ // Check whether used 'out' items
+ if(!dap_chain_ledger_tx_hash_is_used_out_item(&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 = out_item->header.value;
+ l_list_used_out = dap_list_append(l_list_used_out, item);
+ l_value_transfer += item->value;
+ // already accumulated the required value, finish the search for 'out' items
+ if(l_value_transfer >= l_value_need) {
+ break;
+ }
+ }
+ }
+ // go to the next 'out' item in l_tx transaction
+ l_out_idx_tmp++;
+ l_list_tmp = dap_list_next(l_list_tmp);
+ }
+ dap_list_free(l_list_out_items);
+ }
+
+ // nothing to tranfer (not enough funds)
+ if(!l_list_used_out || l_value_transfer < l_value_need) {
+ dap_list_free_full(l_list_used_out, free);
+ return -2;
+ }
+ }
+
+ // create empty transaction
+ dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
+ // 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
+ while(l_list_tmp) {
+ list_used_item_t *item = l_list_tmp->data;
+ if(dap_chain_datum_tx_add_in_item(&l_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);
+ }
+ assert(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
+ if(dap_chain_datum_tx_add_out_cond_item(&l_tx, a_key_cond, (dap_chain_addr_t*) a_addr_cond, a_value, a_cond,
+ a_cond_size) == 1) {
+ l_value_pack += a_value;
+ // 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;
+ }
+ }
+ // coin back
+ uint64_t l_value_back = l_value_transfer - l_value_pack;
+ if(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 -1;
+ }
+ }
+ }
+
+ // add 'sign' items
+ if(dap_chain_datum_tx_add_sign_item(&l_tx, a_key_from) != 1) {
+ dap_chain_datum_tx_delete(l_tx);
+ return -1;
+ }
+
+ size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
+ dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size);
+
+ dap_chain_hash_fast_t l_key_hash;
+ dap_hash_fast(l_tx, l_tx_size, &l_key_hash);
+ DAP_DELETE(l_tx);
+
+ char * l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
+ if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum, dap_chain_datum_size(l_datum)
+ , c_dap_datum_mempool_gdb_group)) {
+ log_it(L_NOTICE, "Transaction %s placed in mempool", l_key_str);
+ // add transaction to ledger
+ if(dap_chain_ledger_tx_add((dap_chain_datum_tx_t*) l_datum->data) < 0)
+ log_it(L_ERROR, "Transaction %s not placed in LEDGER", l_key_str);
+ }
+ DAP_DELETE(l_key_str);*/
+
+ return 0;
+}
+
+uint8_t* dap_datum_mempool_serialize(dap_datum_mempool_t *datum_mempool, size_t *size)
+{
+ size_t a_request_size = 2 * sizeof(uint16_t), shift_size = 0;
+ for(int i = 0; i < datum_mempool->datum_count; i++) {
+ a_request_size += dap_chain_datum_size(datum_mempool->data[i]) + sizeof(uint16_t);
+ }
+ uint8_t *a_request = DAP_NEW_SIZE(uint8_t, a_request_size);
+ memcpy(a_request + shift_size, &(datum_mempool->version), sizeof(uint16_t));
+ shift_size += sizeof(uint16_t);
+ memcpy(a_request + shift_size, &(datum_mempool->datum_count), sizeof(uint16_t));
+ shift_size += sizeof(uint16_t);
+ for(int i = 0; i < datum_mempool->datum_count; i++) {
+ size_t size_one = dap_chain_datum_size(datum_mempool->data[i]);
+ memcpy(a_request + shift_size, &size_one, sizeof(uint16_t));
+ shift_size += sizeof(uint16_t);
+ memcpy(a_request + shift_size, datum_mempool->data[i], size_one);
+ shift_size += size_one;
+ }
+ assert(shift_size == a_request_size);
+ if(size)
+ *size = a_request_size;
+ return a_request;
+}
+
+dap_datum_mempool_t * dap_datum_mempool_deserialize(uint8_t *a_datum_mempool_ser, size_t a_datum_mempool_ser_size)
+{
+ size_t shift_size = 0;
+ //uint8_t *a_datum_mempool_ser = DAP_NEW_Z_SIZE(uint8_t, datum_mempool_size / 2 + 1);
+ //datum_mempool_size = hex2bin(a_datum_mempool_ser, datum_mempool_str_in, datum_mempool_size) / 2;
+ dap_datum_mempool_t *datum_mempool = DAP_NEW_Z(dap_datum_mempool_t);
+ memcpy(&(datum_mempool->version), a_datum_mempool_ser + shift_size, sizeof(uint16_t));
+ shift_size += sizeof(uint16_t);
+ memcpy(&(datum_mempool->datum_count), a_datum_mempool_ser + shift_size, sizeof(uint16_t));
+ shift_size += sizeof(uint16_t);
+ datum_mempool->data = DAP_NEW_Z_SIZE(dap_chain_datum_t*, datum_mempool->datum_count * sizeof(dap_chain_datum_t*));
+ for(int i = 0; i < datum_mempool->datum_count; i++) {
+ size_t size_one = 0;
+ memcpy(&size_one, a_datum_mempool_ser + shift_size, sizeof(uint16_t));
+ shift_size += sizeof(uint16_t);
+ datum_mempool->data[i] = (dap_chain_datum_t*) DAP_NEW_Z_SIZE(uint8_t, size_one);
+ memcpy(datum_mempool->data[i], a_datum_mempool_ser + shift_size, size_one);
+ shift_size += size_one;
+ datum_mempool->data[i];
+ }
+ assert(shift_size == a_datum_mempool_ser_size);
+ DAP_DELETE(a_datum_mempool_ser);
+ return datum_mempool;
+}
+
+void dap_datum_mempool_clean(dap_datum_mempool_t *datum)
+{
+ if(!datum)
+ return;
+ for(int i = 0; i < datum->datum_count; i++) {
+ DAP_DELETE(datum->data[i]);
+ }
+ DAP_DELETE(datum->data);
+ datum->data = NULL;
+}
+
+void dap_datum_mempool_free(dap_datum_mempool_t *datum)
+{
+ dap_datum_mempool_clean(datum);
+ DAP_DELETE(datum);
+}
+
+/**
+ *
+ */
+static char* calc_datum_hash(const char *datum_str, size_t datum_size)
+{
+ dap_chain_hash_fast_t a_hash;
+ dap_hash_fast( datum_str, datum_size, &a_hash);
+ size_t a_str_max = (sizeof(a_hash.raw) + 1) * 2 + 2; /* heading 0x */
+ char *a_str = DAP_NEW_Z_SIZE(char, a_str_max);
+
+// size_t hash_len = dap_chain_hash_fast_to_str(&a_hash, a_str, a_str_max);
+ dap_chain_hash_fast_to_str(&a_hash, a_str, a_str_max);
+
+// if(!hash_len) {
+// DAP_DELETE(a_str);
+// return NULL;
+// }
+
+ return a_str;
+}
+
+static void enc_http_reply_encode_new(struct dap_http_simple *a_http_simple, dap_enc_key_t * key,
+ enc_http_delegate_t * a_http_delegate)
+{
+ //dap_enc_key_t * key = dap_enc_ks_find_http(a_http_simple->http);
+ if(key == NULL) {
+ log_it(L_ERROR, "Can't find http key.");
+ return;
+ }
+ if(a_http_delegate->response) {
+
+ if(a_http_simple->reply)
+ free(a_http_simple->reply);
+
+ size_t l_reply_size_max = dap_enc_code_out_size(a_http_delegate->key,
+ a_http_delegate->response_size,
+ DAP_ENC_DATA_TYPE_RAW);
+
+ a_http_simple->reply = DAP_NEW_SIZE(void, l_reply_size_max);
+ a_http_simple->reply_size = dap_enc_code(a_http_delegate->key,
+ a_http_delegate->response, a_http_delegate->response_size,
+ a_http_simple->reply, l_reply_size_max,
+ DAP_ENC_DATA_TYPE_RAW);
+
+ /*/ decode test
+ size_t l_response_dec_size_max = a_http_simple->reply_size ? a_http_simple->reply_size * 2 + 16 : 0;
+ char * l_response_dec = a_http_simple->reply_size ? DAP_NEW_Z_SIZE(char, l_response_dec_size_max) : NULL;
+ size_t l_response_dec_size = 0;
+ if(a_http_simple->reply_size)
+ l_response_dec_size = dap_enc_decode(a_http_delegate->key,
+ a_http_simple->reply, a_http_simple->reply_size,
+ l_response_dec, l_response_dec_size_max,
+ DAP_ENC_DATA_TYPE_RAW);
+ l_response_dec_size_max = 0;*/
+ }
+
+}
+
+/**
+ * @brief
+ * @param cl_st HTTP server instance
+ * @param arg for return code
+ */
+void chain_mempool_proc(struct dap_http_simple *cl_st, void * arg)
+{
+ http_status_code_t * return_code = (http_status_code_t*) arg;
+ // save key while it alive, i.e. still exist
+ dap_enc_key_t *key = dap_enc_ks_find_http(cl_st->http);
+ //dap_enc_key_serealize_t *key_ser = dap_enc_key_serealize(key_tmp);
+ //dap_enc_key_t *key = dap_enc_key_deserealize(key_ser, sizeof(dap_enc_key_serealize_t));
+
+ // read header
+ dap_http_header_t *hdr_session_close_id =
+ (cl_st->http) ? dap_http_header_find(cl_st->http->in_headers, "SessionCloseAfterRequest") : NULL;
+ dap_http_header_t *hdr_key_id =
+ (hdr_session_close_id && cl_st->http) ? dap_http_header_find(cl_st->http->in_headers, "KeyID") : NULL;
+
+ enc_http_delegate_t *dg = enc_http_request_decode(cl_st);
+ if(dg) {
+ char *suburl = dg->url_path;
+ char *request_str = dg->request_str;
+ int request_size = (int) dg->request_size;
+ //printf("!!***!!! chain_mempool_proc arg=%d suburl=%s str=%s len=%d\n", arg, suburl, request_str, request_size);
+ if(request_str && request_size > 1) {
+ // find what to do
+ uint8_t action = DAP_DATUM_MEMPOOL_NONE; //*(uint8_t*) request_str;
+ if(dg->url_path_size > 0) {
+ if(!strcmp(suburl, "add"))
+ action = DAP_DATUM_MEMPOOL_ADD;
+ else if(!strcmp(suburl, "check"))
+ action = DAP_DATUM_MEMPOOL_CHECK;
+ else if(!strcmp(suburl, "del"))
+ action = DAP_DATUM_MEMPOOL_DEL;
+ }
+ dap_datum_mempool_t *datum_mempool =
+ (action != DAP_DATUM_MEMPOOL_NONE) ?
+ dap_datum_mempool_deserialize((uint8_t*) request_str, (size_t) request_size) : NULL;
+ if(datum_mempool)
+ {
+ dap_datum_mempool_free(datum_mempool);
+ char *a_key = calc_datum_hash(request_str, (size_t) request_size);
+ char *a_value;
+ switch (action)
+ {
+ case DAP_DATUM_MEMPOOL_ADD: // add datum in base
+ //a_value = DAP_NEW_Z_SIZE(char, request_size * 2);
+ //bin2hex((char*) a_value, (const unsigned char*) request_str, request_size);
+ if(dap_chain_global_db_gr_set(dap_strdup(a_key), request_str,(size_t) request_size,
+ dap_config_get_item_str_default(g_config, "mempool", "gdb_group", "datum-pool"))) {
+ *return_code = Http_Status_OK;
+ }
+ log_it(L_INFO, "Insert hash: key=%s result:%s", a_key,
+ (*return_code == Http_Status_OK) ? "OK" : "False!");
+ DAP_DELETE(a_key);
+ break;
+
+ case DAP_DATUM_MEMPOOL_CHECK: // check datum in base
+
+ strcpy(cl_st->reply_mime, "text/text");
+ char *str = dap_chain_global_db_gr_get( dap_strdup(a_key) , NULL,
+ dap_config_get_item_str_default(g_config, "mempool", "gdb_group", "datum-pool"));
+ if(str) {
+ dg->response = strdup("1");
+ DAP_DELETE(str);
+ log_it(L_INFO, "Check hash: key=%s result: Present", a_key);
+ }
+ else
+ {
+ dg->response = strdup("0");
+ log_it(L_INFO, "Check hash: key=%s result: Absent", a_key);
+ }
+ dg->response_size = strlen(dg->response);
+ *return_code = Http_Status_OK;
+ enc_http_reply_encode_new(cl_st, key, dg);
+ break;
+
+ case DAP_DATUM_MEMPOOL_DEL: // delete datum in base
+ strcpy(cl_st->reply_mime, "text/text");
+ if(dap_chain_global_db_gr_del( dap_strdup(a_key),
+ dap_config_get_item_str_default(g_config, "mempool", "gdb_group", "datum-pool"))) {
+ dg->response = strdup("1");
+
+ log_it(L_INFO, "Delete hash: key=%s result: Ok", a_key);
+ }
+ else
+ {
+ dg->response = strdup("0");
+ log_it(L_INFO, "Delete hash: key=%s result: False!", a_key);
+ }
+ *return_code = Http_Status_OK;
+ enc_http_reply_encode_new(cl_st, key, dg);
+ break;
+
+ default: // unsupported command
+ log_it(L_INFO, "Unknown request=%s! key=%s", (suburl) ? suburl : "-", a_key);
+ DAP_DELETE(a_key);
+ enc_http_delegate_delete(dg);
+ if(key)
+ dap_enc_key_delete(key);
+ return;
+ }
+ DAP_DELETE(a_key);
+ }
+ else
+ *return_code = Http_Status_BadRequest;
+ }
+ else
+ *return_code = Http_Status_BadRequest;
+ enc_http_delegate_delete(dg);
+ }
+ else {
+ *return_code = Http_Status_Unauthorized;
+ }
+ if(hdr_session_close_id && hdr_session_close_id->value && !strcmp(hdr_session_close_id->value, "yes")) {
+ // close session
+ if(hdr_key_id && hdr_key_id->value) {
+ dap_enc_ks_delete(hdr_key_id->value);
+ }
+ }
+}
+
+/**
+ * @brief chain_mempool_add_proc
+ * @param sh HTTP server instance
+ * @param url URL string
+ */
+void dap_chain_mempool_add_proc(dap_http_t * a_http_server, const char * a_url)
+{
+ dap_http_simple_proc_add(a_http_server, a_url, 4096, chain_mempool_proc);
+}
diff --git a/libdap-chain-mempool/dap_chain_mempool.h b/libdap-chain-mempool/dap_chain_mempool.h
new file mode 100755
index 0000000000000000000000000000000000000000..abe82a61fcae79d6afb4fc9cb3fa33f91b98688d
--- /dev/null
+++ b/libdap-chain-mempool/dap_chain_mempool.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <stdint.h>
+#include "dap_chain_datum.h"
+#include "dap_chain_net.h"
+#include "dap_chain_ledger.h"
+#include "dap_http.h"
+/*
+ // datum mempool structure
+ typedef struct dap_datum_mempool {
+ int16_t version; // structure version
+ uint16_t datum_count; // datums count
+ struct {
+ int32_t datum_size;
+ dap_chain_datum_t *datum;
+ }DAP_ALIGN_PACKED data[]; // mass of datums
+ }DAP_ALIGN_PACKED dap_datum_mempool_t;
+ */
+
+#define DAP_DATUM_MEMPOOL_VERSION "01"
+
+// action
+enum {
+ DAP_DATUM_MEMPOOL_NONE = 0, DAP_DATUM_MEMPOOL_ADD, DAP_DATUM_MEMPOOL_CHECK, DAP_DATUM_MEMPOOL_DEL
+};
+
+// datum mempool structure
+typedef struct dap_datum_mempool {
+ uint16_t version; // structure version
+ uint16_t datum_count; // datums count
+ dap_chain_datum_t **data;// mass of datums
+}DAP_ALIGN_PACKED dap_datum_mempool_t;
+
+int dap_datum_mempool_init(void);
+
+extern const char* c_dap_datum_mempool_gdb_group;
+
+uint8_t* dap_datum_mempool_serialize(dap_datum_mempool_t *datum_mempool, size_t *size);
+dap_datum_mempool_t * dap_datum_mempool_deserialize(uint8_t *datum_mempool_str, size_t size);
+
+void dap_datum_mempool_clean(dap_datum_mempool_t *datum);
+void dap_datum_mempool_free(dap_datum_mempool_t *datum);
+
+void dap_chain_mempool_add_proc(dap_http_t * a_http_server, const char * a_url);
+
+int dap_chain_mempool_tx_create(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);
+
+// 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);
+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);
+
+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_datum_add(dap_chain_datum_t * a_datum, dap_chain_t * a_chain );
+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);