From 70995def62f9a195a22a0d15d808df0596805e6b Mon Sep 17 00:00:00 2001
From: cellframe <roman.khlopkov@demlabs.net>
Date: Fri, 4 Nov 2022 21:07:40 +0300
Subject: [PATCH] [*] Build fix
---
dap-sdk/core/src/dap_file_utils.c | 4 +-
dap-sdk/crypto/src/dap_enc_dilithium.c | 4 +-
dap-sdk/crypto/src/dap_enc_tesla.c | 16 +-
.../dap_chain_global_db_driver_mdbx.c | 8 +-
.../stake_lock/dap_chain_net_srv_stake_lock.c | 1424 +++++++++--------
modules/type/dag/dap_chain_cs_dag.c | 17 +-
6 files changed, 738 insertions(+), 735 deletions(-)
diff --git a/dap-sdk/core/src/dap_file_utils.c b/dap-sdk/core/src/dap_file_utils.c
index cf643a1c72..273c76e084 100755
--- a/dap-sdk/core/src/dap_file_utils.c
+++ b/dap-sdk/core/src/dap_file_utils.c
@@ -158,7 +158,7 @@ bool dap_dir_test(const char * a_dir_path)
/**
* @brief dap_mkdir_with_parents Create a new directory with intermediate sub-directories
- *
+ *
* @param a_dir_path new directory pathname
* @return int 0, if the directory was created or already exist, else -1
*/
@@ -643,7 +643,7 @@ static bool dap_get_contents_regfile(const char *filename, struct stat *stat_buf
bytes_read = 0;
while(bytes_read < size) {
- size_t rc;
+ ssize_t rc;
rc = read(fd, buf + bytes_read, size - bytes_read);
diff --git a/dap-sdk/crypto/src/dap_enc_dilithium.c b/dap-sdk/crypto/src/dap_enc_dilithium.c
index 18e998439a..5a604cac6b 100755
--- a/dap-sdk/crypto/src/dap_enc_dilithium.c
+++ b/dap-sdk/crypto/src/dap_enc_dilithium.c
@@ -54,7 +54,7 @@ void dap_enc_sig_dilithium_key_new_generate(struct dap_enc_key * key, const void
key->pub_key_data = malloc(key->pub_key_data_size);
retcode = dilithium_crypto_sign_keypair((dilithium_public_key_t *) key->pub_key_data,
- (dilithium_private_key_t *) key->priv_key_data, _dilithium_type, seed, seed_size);
+ (dilithium_private_key_t *) key->priv_key_data, (dilithium_kind_t)_dilithium_type, seed, seed_size);
if(retcode != 0) {
dilithium_private_and_public_keys_delete((dilithium_private_key_t *) key->pub_key_data,
(dilithium_public_key_t *) key->pub_key_data);
@@ -454,7 +454,7 @@ dilithium_public_key_t* dap_enc_dilithium_read_public_key(const uint8_t *a_buf,
} else {
memcpy(&kind, a_buf + sizeof(uint64_t), sizeof(uint32_t));
}
- dilithium_param_t p;
+ dilithium_param_t p;
if(!dilithium_params_init(&p, kind)){
log_it(L_ERROR,"::read_public_key() Can't find params for signature kind %d", kind);
return NULL;
diff --git a/dap-sdk/crypto/src/dap_enc_tesla.c b/dap-sdk/crypto/src/dap_enc_tesla.c
index 54e40d2e09..9eb9fbdc7e 100755
--- a/dap-sdk/crypto/src/dap_enc_tesla.c
+++ b/dap-sdk/crypto/src/dap_enc_tesla.c
@@ -32,13 +32,13 @@ void dap_enc_sig_tesla_key_new(struct dap_enc_key *key) {
// alice_msg_len --- Alice's private key length
/**
* @brief dap_enc_sig_tesla_key_new_generate
- *
- * @param key
- * @param kex_buf
- * @param kex_size
- * @param seed
- * @param seed_size
- * @param key_size
+ *
+ * @param key
+ * @param kex_buf
+ * @param kex_size
+ * @param seed
+ * @param seed_size
+ * @param key_size
*/
void dap_enc_sig_tesla_key_new_generate(struct dap_enc_key * key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
@@ -66,7 +66,7 @@ void dap_enc_sig_tesla_key_new_generate(struct dap_enc_key * key, const void *ke
key->pub_key_data = malloc(key->pub_key_data_size);
retcode = tesla_crypto_sign_keypair((tesla_public_key_t *) key->pub_key_data,
- (tesla_private_key_t *) key->priv_key_data, _tesla_type, seed, seed_size);
+ (tesla_private_key_t *) key->priv_key_data, (tesla_kind_t)_tesla_type, seed, seed_size);
if(retcode != 0) {
tesla_private_and_public_keys_delete((tesla_private_key_t *) key->pub_key_data,
(tesla_public_key_t *) key->pub_key_data);
diff --git a/modules/global-db/dap_chain_global_db_driver_mdbx.c b/modules/global-db/dap_chain_global_db_driver_mdbx.c
index 62090f899a..8da7cc0b25 100644
--- a/modules/global-db/dap_chain_global_db_driver_mdbx.c
+++ b/modules/global-db/dap_chain_global_db_driver_mdbx.c
@@ -88,7 +88,7 @@ static int s_db_mdbx_deinit();
static int s_db_mdbx_flush(void);
static int s_db_mdbx_apply_store_obj (dap_store_obj_t *a_store_obj);
static dap_store_obj_t *s_db_mdbx_read_last_store_obj(const char* a_group);
-static int s_db_mdbx_is_obj(const char *a_group, const char *a_key);
+static bool s_db_mdbx_is_obj(const char *a_group, const char *a_key);
static dap_store_obj_t *s_db_mdbx_read_store_obj(const char *a_group, const char *a_key, size_t *a_count_out);
static dap_store_obj_t *s_db_mdbx_read_cond_store_obj(const char *a_group, uint64_t a_id, size_t *a_count_out);
static size_t s_db_mdbx_read_count_store(const char *a_group, uint64_t a_id);
@@ -459,7 +459,7 @@ size_t l_upper_limit_of_db_size = 16;
a_drv_dpt->read_cond_store_obj = s_db_mdbx_read_cond_store_obj;
a_drv_dpt->read_count_store = s_db_mdbx_read_count_store;
a_drv_dpt->get_groups_by_mask = s_db_mdbx_get_groups_by_mask;
- a_drv_dpt->is_obj = (dap_db_driver_is_obj_callback_t) s_db_mdbx_is_obj;
+ a_drv_dpt->is_obj = s_db_mdbx_is_obj;
a_drv_dpt->deinit = s_db_mdbx_deinit;
a_drv_dpt->flush = s_db_mdbx_flush;
@@ -651,7 +651,7 @@ dap_store_obj_t *l_obj;
* 1 - SUCCESS, record is exist
* 0 - Record-No-Found
*/
-int s_db_mdbx_is_obj(const char *a_group, const char *a_key)
+bool s_db_mdbx_is_obj(const char *a_group, const char *a_key)
{
int l_rc, l_rc2;
dap_db_ctx_t *l_db_ctx;
@@ -1260,7 +1260,7 @@ struct __record_suffix__ *l_suff;
*/
l_rc2 = l_count_out * sizeof(dap_store_obj_t);
if ( !(l_obj_arr = (dap_store_obj_t *) DAP_NEW_Z_SIZE(char, l_rc2)) ) {
- log_it(L_ERROR, "Cannot allocate %zu octets for %d store objects", l_count_out * sizeof(dap_store_obj_t), l_count_out);
+ log_it(L_ERROR, "Cannot allocate %zu octets for %"DAP_UINT64_FORMAT_U" store objects", l_count_out * sizeof(dap_store_obj_t), l_count_out);
break;
}
diff --git a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
index c665c87c83..9e5d0bb988 100644
--- a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
+++ b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
@@ -8,18 +8,18 @@
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/>.
+ 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 "dap_chain_net_srv.h"
@@ -81,12 +81,12 @@ enum error_code {
* @brief The cond_params struct thats placed in tx_cond->params[] section
*/
typedef struct cond_params {
- dap_time_t time_unlock;
- uint32_t flags;
+ dap_time_t time_unlock;
+ uint32_t flags;
uint8_t reinvest;
uint8_t padding[7];
- dap_hash_fast_t token_delegated; // Delegate token
- dap_hash_fast_t pkey_delegated; // Delegate public key
+ dap_hash_fast_t token_delegated; // Delegate token
+ dap_hash_fast_t pkey_delegated; // Delegate public key
} DAP_ALIGN_PACKED cond_params_t;
typedef struct dap_chain_ledger_token_emission_for_stake_lock_item {
@@ -111,21 +111,21 @@ dap_chain_ledger_token_emission_for_stake_lock_item_t *s_emission_for_stake_lock
*/
int dap_chain_net_srv_stake_lock_init()
{
- dap_cli_server_cmd_add("stake_lock", s_cli_stake_lock, "Stake lock service commands",
+ dap_cli_server_cmd_add("stake_lock", s_cli_stake_lock, "Stake lock service commands",
"stake_lock hold -net <net_name> -wallet <wallet_name> -time_staking <in YYMMDD>\n"
"\t-token <token_ticker> -coins <value> -reinvest <percentage from 1 to 100 (not necessary)>\n"
"\t-cert <priv_cert_name> -chain <chain (not necessary)> -chain_emission <chain (not necessary)>\n"
"stake_lock take -net <net_name> -tx <transaction_hash> -wallet <wallet_name>\n"
"\t-chain <chain (not necessary)>\n"
- );
+ );
s_debug_more = dap_config_get_item_bool_default(g_config,"ledger","debug_more",false);
dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_STAKE_LOCK_ID };
dap_chain_net_srv_callbacks_t l_srv_callbacks = {};
l_srv_callbacks.decree = s_callback_decree;
- dap_chain_net_srv_t* l_srv = dap_chain_net_srv_add(l_uid, "stake_lock", &l_srv_callbacks);
- return 0;
+ dap_chain_net_srv_t* l_srv = dap_chain_net_srv_add(l_uid, "stake_lock", &l_srv_callbacks);
+ return 0;
}
/**
@@ -158,17 +158,17 @@ static void s_callback_decree(dap_chain_net_srv_t* a_srv, dap_chain_net_t* a_net
*/
static dap_chain_datum_tx_receipt_t* s_receipt_create(dap_hash_fast_t* hash_burning_transaction, const char* token, uint256_t datoshi_burned)
{
- uint32_t l_ext_size = sizeof(dap_hash_fast_t) + dap_strlen(token) + 1;
- uint8_t* l_ext = DAP_NEW_STACK_SIZE(uint8_t, l_ext_size);
+ uint32_t l_ext_size = sizeof(dap_hash_fast_t) + dap_strlen(token) + 1;
+ uint8_t* l_ext = DAP_NEW_STACK_SIZE(uint8_t, l_ext_size);
- memcpy(l_ext, hash_burning_transaction, sizeof(dap_hash_fast_t));
- strcpy((char*)&l_ext[sizeof(dap_hash_fast_t)], token);
+ memcpy(l_ext, hash_burning_transaction, sizeof(dap_hash_fast_t));
+ strcpy((char*)&l_ext[sizeof(dap_hash_fast_t)], token);
- 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_STAKE_LOCK_ID };
- dap_chain_datum_tx_receipt_t* l_receipt = dap_chain_datum_tx_receipt_create(l_uid, l_unit, 0, datoshi_burned,
- l_ext, l_ext_size);
- return l_receipt;
+ 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_STAKE_LOCK_ID };
+ dap_chain_datum_tx_receipt_t* l_receipt = dap_chain_datum_tx_receipt_create(l_uid, l_unit, 0, datoshi_burned,
+ l_ext, l_ext_size);
+ return l_receipt;
}
/**
@@ -206,27 +206,27 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
dap_tsd_t *l_tsd;
dap_chain_datum_token_tsd_delegate_from_stake_lock_t l_tsd_section;
- dap_string_append_printf(output_line, "---> HOLD <---\n");
+ dap_string_append_printf(output_line, "---> HOLD <---\n");
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
- || NULL == l_net_str)
- return NET_ARG_ERROR;
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
+ || NULL == l_net_str)
+ return NET_ARG_ERROR;
- if (NULL == (l_net = dap_chain_net_by_name(l_net_str))) {
- dap_string_append_printf(output_line, "'%s'", l_net_str);
- return NET_ERROR;
- }
+ if (NULL == (l_net = dap_chain_net_by_name(l_net_str))) {
+ dap_string_append_printf(output_line, "'%s'", l_net_str);
+ return NET_ERROR;
+ }
if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-token", &l_ticker_str)
|| NULL == l_ticker_str
|| dap_strlen(l_ticker_str) > 8) // for 'm' delegated
- return TOKEN_ARG_ERROR;
+ return TOKEN_ARG_ERROR;
l_ledger = l_net->pub.ledger;
if (NULL == dap_chain_ledger_token_ticker_check(l_ledger, l_ticker_str)) {
dap_string_append_printf(output_line, "'%s'", l_ticker_str);
- return TOKEN_ERROR;
- }
+ return TOKEN_ERROR;
+ }
strcpy(delegate_ticker_str + 1, l_ticker_str);
@@ -243,11 +243,11 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
return TOKEN_ERROR;
if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-coins", &l_coins_str)
- || NULL == l_coins_str)
- return COINS_ARG_ERROR;
+ || NULL == l_coins_str)
+ return COINS_ARG_ERROR;
- if (IS_ZERO_256((l_value = dap_chain_balance_scan(l_coins_str))))
- return COINS_FORMAT_ERROR;
+ if (IS_ZERO_256((l_value = dap_chain_balance_scan(l_coins_str))))
+ return COINS_FORMAT_ERROR;
if (!IS_ZERO_256(l_tsd_section.emission_rate)) {
MULT_256_COIN(l_value, l_tsd_section.emission_rate, &l_value_delegated);
@@ -257,45 +257,45 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
l_value_delegated = l_value;
}
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str)
- || NULL == l_cert_str)
- return CERT_ARG_ERROR;
-
- if (NULL == (l_cert = dap_cert_find_by_name(l_cert_str))) {
- dap_string_append_printf(output_line, "'%s'", l_cert_str);
- return CERT_LOAD_ERROR;
- }
-
- if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
- && l_chain_str)
- l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
- else
- l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_TX);
- if (!l_chain)
- return CHAIN_ERROR;
-
- if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain_emission", &l_chain_emission_str)
- && l_chain_emission_str)
- l_chain_emission = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
- else
- l_chain_emission = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_EMISSION);
- if (!l_chain_emission)
- return CHAIN_EMISSION_ERROR;
-
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
- || NULL == l_wallet_str)
- return WALLET_ARG_ERROR;
-
- // Read time staking
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-time_staking", &l_time_staking_str)
- || NULL == l_time_staking_str)
- return TIME_ERROR;
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str)
+ || NULL == l_cert_str)
+ return CERT_ARG_ERROR;
+
+ if (NULL == (l_cert = dap_cert_find_by_name(l_cert_str))) {
+ dap_string_append_printf(output_line, "'%s'", l_cert_str);
+ return CERT_LOAD_ERROR;
+ }
+
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
+ && l_chain_str)
+ l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
+ else
+ l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_TX);
+ if (!l_chain)
+ return CHAIN_ERROR;
+
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain_emission", &l_chain_emission_str)
+ && l_chain_emission_str)
+ l_chain_emission = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
+ else
+ l_chain_emission = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_EMISSION);
+ if (!l_chain_emission)
+ return CHAIN_EMISSION_ERROR;
+
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
+ || NULL == l_wallet_str)
+ return WALLET_ARG_ERROR;
+
+ // Read time staking
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-time_staking", &l_time_staking_str)
+ || NULL == l_time_staking_str)
+ return TIME_ERROR;
if (0 == (l_time_staking = dap_time_from_str_simplified(l_time_staking_str))
- || (time_t)(l_time_staking - dap_time_now()) <= 0)
- return TIME_ERROR;
+ || (time_t)(l_time_staking - dap_time_now()) <= 0)
+ return TIME_ERROR;
- l_time_staking -= dap_time_now();
+ l_time_staking -= dap_time_now();
if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-l_reinvest_percent", &l_reinvest_percent_str)
&& NULL != l_reinvest_percent_str) {
@@ -306,77 +306,77 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
/*________________________________________________________________________________________________________________*/
- if (NULL == (l_wallet = dap_chain_wallet_open(l_wallet_str, l_wallets_path))) {
- dap_string_append_printf(output_line, "'%s'", l_wallet_str);
- return WALLET_OPEN_ERROR;
- }
+ if (NULL == (l_wallet = dap_chain_wallet_open(l_wallet_str, l_wallets_path))) {
+ dap_string_append_printf(output_line, "'%s'", l_wallet_str);
+ return WALLET_OPEN_ERROR;
+ }
if (compare256(dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_ticker_str), l_value) == -1) {
- dap_chain_wallet_close(l_wallet);
- return NO_MONEY_ERROR;
- }
-
- if (NULL == (l_addr_holder = dap_chain_wallet_get_addr(l_wallet, l_net->pub.id))) {
- dap_chain_wallet_close(l_wallet);
- dap_string_append_printf(output_line, "'%s'", l_wallet_str);
- return WALLET_ADDR_ERROR;
- }
-
- l_key_from = dap_chain_wallet_get_key(l_wallet, 0);
- if (NULL == (l_key_cond = dap_pkey_from_enc_key(l_cert->enc_key))) {
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_addr_holder);
- dap_string_append_printf(output_line, "'%s'", l_cert_str);
- return CERT_KEY_ERROR;
- }
+ dap_chain_wallet_close(l_wallet);
+ return NO_MONEY_ERROR;
+ }
+
+ if (NULL == (l_addr_holder = dap_chain_wallet_get_addr(l_wallet, l_net->pub.id))) {
+ dap_chain_wallet_close(l_wallet);
+ dap_string_append_printf(output_line, "'%s'", l_wallet_str);
+ return WALLET_ADDR_ERROR;
+ }
+
+ l_key_from = dap_chain_wallet_get_key(l_wallet, 0);
+ if (NULL == (l_key_cond = dap_pkey_from_enc_key(l_cert->enc_key))) {
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_addr_holder);
+ dap_string_append_printf(output_line, "'%s'", l_cert_str);
+ return CERT_KEY_ERROR;
+ }
l_tx_cond_hash = dap_chain_net_srv_stake_lock_mempool_create(l_net, l_key_from, l_key_cond,
l_ticker_str, l_value, l_uid,
l_addr_holder, l_time_staking, l_reinvest_percent);
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_key_cond);
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_key_cond);
- l_hash_str = (l_tx_cond_hash) ? dap_chain_hash_fast_to_str_new(l_tx_cond_hash) : NULL;
+ l_hash_str = (l_tx_cond_hash) ? dap_chain_hash_fast_to_str_new(l_tx_cond_hash) : NULL;
- if (l_hash_str)
- dap_string_append_printf(output_line, "TX STAKE LOCK CREATED\nSuccessfully hash=%s\nSave to take!\n", l_hash_str);
- else {
- DAP_DEL_Z(l_addr_holder);
- return CREATE_LOCK_TX_ERROR;
- }
+ if (l_hash_str)
+ dap_string_append_printf(output_line, "TX STAKE LOCK CREATED\nSuccessfully hash=%s\nSave to take!\n", l_hash_str);
+ else {
+ DAP_DEL_Z(l_addr_holder);
+ return CREATE_LOCK_TX_ERROR;
+ }
- DAP_DEL_Z(l_hash_str);
+ DAP_DEL_Z(l_hash_str);
- l_base_tx_hash = dap_chain_mempool_base_tx_create(l_chain_emission, l_tx_cond_hash, l_chain_emission->id,
+ l_base_tx_hash = dap_chain_mempool_base_tx_create(l_chain_emission, l_tx_cond_hash, l_chain_emission->id,
l_value_delegated, delegate_ticker_str, l_addr_holder,
&l_cert, 1);
- l_hash_str = (l_base_tx_hash) ? dap_chain_hash_fast_to_str_new(l_base_tx_hash) : NULL;
+ l_hash_str = (l_base_tx_hash) ? dap_chain_hash_fast_to_str_new(l_base_tx_hash) : NULL;
- if (l_hash_str)
- dap_string_append_printf(output_line, "BASE_TX_DATUM_HASH=%s\n", l_hash_str);
- else {
- DAP_DEL_Z(l_addr_holder);
- DAP_DEL_Z(l_tx_cond_hash);
- return BASE_TX_CREATE_ERROR;
- }
+ if (l_hash_str)
+ dap_string_append_printf(output_line, "BASE_TX_DATUM_HASH=%s\n", l_hash_str);
+ else {
+ DAP_DEL_Z(l_addr_holder);
+ DAP_DEL_Z(l_tx_cond_hash);
+ return BASE_TX_CREATE_ERROR;
+ }
- DAP_DEL_Z(l_addr_holder);
- DAP_DEL_Z(l_tx_cond_hash);
- DAP_DEL_Z(l_base_tx_hash);
- DAP_DEL_Z(l_hash_str);
+ DAP_DEL_Z(l_addr_holder);
+ DAP_DEL_Z(l_tx_cond_hash);
+ DAP_DEL_Z(l_base_tx_hash);
+ DAP_DEL_Z(l_hash_str);
- return STAKE_NO_ERROR;
+ return STAKE_NO_ERROR;
}
static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, dap_string_t* output_line)
{
const char *l_net_str, *l_ticker_str, *l_wallet_str, *l_tx_str, *l_tx_burning_str, *l_chain_str;
l_net_str = l_ticker_str = l_wallet_str = l_tx_str = l_tx_burning_str = l_chain_str = NULL;
- dap_chain_net_t* l_net = NULL;
- const char* l_wallets_path = dap_chain_wallet_get_path(g_config);
+ dap_chain_net_t* l_net = NULL;
+ const char* l_wallets_path = dap_chain_wallet_get_path(g_config);
char delegate_ticker_str[DAP_CHAIN_TICKER_SIZE_MAX] = {[0] = 'm'};
int l_prev_cond_idx = 0;
uint256_t l_value_delegated = {};
@@ -384,8 +384,8 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
char *l_datum_hash_str;
dap_ledger_t *l_ledger;
dap_chain_wallet_t *l_wallet;
- dap_hash_fast_t l_tx_hash;
- dap_hash_fast_t l_tx_burning_hash;
+ dap_hash_fast_t l_tx_hash;
+ dap_hash_fast_t l_tx_burning_hash;
dap_chain_datum_t *l_datum_burning_tx;
dap_chain_datum_tx_receipt_t *l_receipt;
dap_chain_datum_tx_t *l_tx;
@@ -393,40 +393,40 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
dap_chain_tx_out_cond_t *l_tx_out_cond;
dap_chain_addr_t *l_owner_addr;
dap_enc_key_t *l_owner_key;
- size_t l_tx_size;
+ size_t l_tx_size;
dap_chain_datum_t *l_datum;
dap_chain_t *l_chain;
dap_chain_datum_token_t *delegate_token;
dap_tsd_t *l_tsd;
dap_chain_datum_token_tsd_delegate_from_stake_lock_t l_tsd_section;
- dap_string_append_printf(output_line, "---> TAKE <---\n");
+ dap_string_append_printf(output_line, "---> TAKE <---\n");
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
- || NULL == l_net_str)
- return NET_ARG_ERROR;
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
+ || NULL == l_net_str)
+ return NET_ARG_ERROR;
- if (NULL == (l_net = dap_chain_net_by_name(l_net_str))) {
- dap_string_append_printf(output_line, "'%s'", l_net_str);
- return NET_ERROR;
- }
+ if (NULL == (l_net = dap_chain_net_by_name(l_net_str))) {
+ dap_string_append_printf(output_line, "'%s'", l_net_str);
+ return NET_ERROR;
+ }
- if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
- && l_chain_str)
- l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
- else
- l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_TX);
- if (!l_chain)
- return CHAIN_ERROR;
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
+ && l_chain_str)
+ l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
+ else
+ l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_TX);
+ if (!l_chain)
+ return CHAIN_ERROR;
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-tx", &l_tx_str)
- || NULL == l_tx_str)
- return TX_ARG_ERROR;
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-tx", &l_tx_str)
+ || NULL == l_tx_str)
+ return TX_ARG_ERROR;
- dap_chain_hash_fast_from_hex_str(l_tx_str, &l_tx_hash);
+ dap_chain_hash_fast_from_hex_str(l_tx_str, &l_tx_hash);
- if (dap_hash_fast_is_blank(&l_tx_hash))
- return HASH_IS_BLANK_ERROR;
+ if (dap_hash_fast_is_blank(&l_tx_hash))
+ return HASH_IS_BLANK_ERROR;
l_ledger = l_net->pub.ledger;
@@ -441,33 +441,34 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
|| !delegate_token->header_native_decl.tsd_total_size
|| NULL == (l_tsd = dap_tsd_find(delegate_token->data_n_tsd, delegate_token->header_native_decl.tsd_total_size, DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DELEGATE_EMISSION_FROM_STAKE_LOCK))) {
dap_string_append_printf(output_line, "'%s'", delegate_ticker_str);
- return NO_DELEGATE_TOKEN_ERROR;
+ return NO_DELEGATE_TOKEN_ERROR;
}
l_tsd_section = dap_tsd_get_scalar(l_tsd, dap_chain_datum_token_tsd_delegate_from_stake_lock_t);
- if (strcmp(l_ticker_str, l_tsd_section.ticker_token_from))
+ if (strcmp(l_ticker_str, l_tsd_section.ticker_token_from)) {
return TOKEN_ERROR;
+ }
- l_cond_tx = dap_chain_ledger_tx_find_by_hash(l_ledger, &l_tx_hash);
+ l_cond_tx = dap_chain_ledger_tx_find_by_hash(l_ledger, &l_tx_hash);
- if (NULL == (l_tx_out_cond = dap_chain_datum_tx_out_cond_get(l_cond_tx, &l_prev_cond_idx)))
- return NO_TX_ERROR;
+ if (NULL == (l_tx_out_cond = dap_chain_datum_tx_out_cond_get(l_cond_tx, &l_prev_cond_idx)))
+ return NO_TX_ERROR;
- if (l_tx_out_cond->header.subtype != DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK)
- return NO_VALID_SUBTYPE_ERROR;
+ if (l_tx_out_cond->header.subtype != DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK)
+ return NO_VALID_SUBTYPE_ERROR;
- if (dap_chain_ledger_tx_hash_is_used_out_item(l_ledger, &l_tx_hash, l_prev_cond_idx)) {
- return IS_USED_OUT_ERROR;
- }
+ if (dap_chain_ledger_tx_hash_is_used_out_item(l_ledger, &l_tx_hash, l_prev_cond_idx)) {
+ return IS_USED_OUT_ERROR;
+ }
- if (l_tx_out_cond->params_size != sizeof(*l_params))// Wrong params size
- return WRONG_PARAM_SIZE;
- l_params = (cond_params_t*)l_tx_out_cond->params;
+ if (l_tx_out_cond->params_size != sizeof(*l_params))// Wrong params size
+ return WRONG_PARAM_SIZE;
+ l_params = (cond_params_t*)l_tx_out_cond->params;
- if (l_params->flags & DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_BY_TIME) {
- if (l_params->time_unlock > dap_time_now())
- return NOT_ENOUGH_TIME;
- }
+ if (l_params->flags & DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_BY_TIME) {
+ if (l_params->time_unlock > dap_time_now())
+ return NOT_ENOUGH_TIME;
+ }
if (!IS_ZERO_256(l_tsd_section.emission_rate)) {
MULT_256_COIN(l_tx_out_cond->header.value, l_tsd_section.emission_rate, &l_value_delegated);
@@ -477,103 +478,103 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
l_value_delegated = l_tx_out_cond->header.value;
}
- if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
- || NULL == l_wallet_str)
- return WALLET_ARG_ERROR;
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
+ || NULL == l_wallet_str)
+ return WALLET_ARG_ERROR;
- if (NULL == (l_wallet = dap_chain_wallet_open(l_wallet_str, l_wallets_path)))
- return WALLET_OPEN_ERROR;
+ if (NULL == (l_wallet = dap_chain_wallet_open(l_wallet_str, l_wallets_path)))
+ return WALLET_OPEN_ERROR;
- if (NULL == (l_owner_addr = (dap_chain_addr_t*)dap_chain_wallet_get_addr(l_wallet, l_net->pub.id))) {
- dap_chain_wallet_close(l_wallet);
- return WALLET_ADDR_ERROR;
- }
+ if (NULL == (l_owner_addr = (dap_chain_addr_t*)dap_chain_wallet_get_addr(l_wallet, l_net->pub.id))) {
+ dap_chain_wallet_close(l_wallet);
+ return WALLET_ADDR_ERROR;
+ }
- if (NULL == (l_owner_key = dap_chain_wallet_get_key(l_wallet, 0))) {
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_owner_addr);
- return OWNER_KEY_ERROR;
- }
+ if (NULL == (l_owner_key = dap_chain_wallet_get_key(l_wallet, 0))) {
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_owner_addr);
+ return OWNER_KEY_ERROR;
+ }
- /*________________________________________________________________________________________________________________*/
+ /*________________________________________________________________________________________________________________*/
- //add tx
- if (NULL == (l_tx = dap_chain_datum_tx_create())) {//malloc
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_owner_addr);
- return CREATE_TX_ERROR;
- }
+ //add tx
+ if (NULL == (l_tx = dap_chain_datum_tx_create())) {//malloc
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_owner_addr);
+ return CREATE_TX_ERROR;
+ }
- dap_chain_datum_tx_add_in_cond_item(&l_tx, &l_tx_hash, l_prev_cond_idx, 0);
+ dap_chain_datum_tx_add_in_cond_item(&l_tx, &l_tx_hash, l_prev_cond_idx, 0);
- dap_chain_datum_tx_add_out_item(&l_tx, l_owner_addr, l_tx_out_cond->header.value);
+ dap_chain_datum_tx_add_out_item(&l_tx, l_owner_addr, l_tx_out_cond->header.value);
- //add burning tx
- if (NULL == (l_datum_burning_tx = dap_chain_burning_tx_create(l_chain, l_owner_key, l_owner_addr, NULL,
+ //add burning tx
+ if (NULL == (l_datum_burning_tx = dap_chain_burning_tx_create(l_chain, l_owner_key, l_owner_addr, NULL,
delegate_ticker_str, l_value_delegated))) {//malloc
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_owner_addr);
- dap_chain_datum_tx_delete(l_tx);
- return CREATE_BURNING_TX_ERROR;
- }
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_owner_addr);
+ dap_chain_datum_tx_delete(l_tx);
+ return CREATE_BURNING_TX_ERROR;
+ }
- //get tx hash
- dap_hash_fast(l_datum_burning_tx->data, l_datum_burning_tx->header.data_size, &l_tx_burning_hash);
+ //get tx hash
+ dap_hash_fast(l_datum_burning_tx->data, l_datum_burning_tx->header.data_size, &l_tx_burning_hash);
if (NULL == (l_receipt = s_receipt_create(&l_tx_burning_hash, delegate_ticker_str, l_value_delegated))) {
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_owner_addr);
- dap_chain_datum_tx_delete(l_tx);
- DAP_DEL_Z(l_datum_burning_tx);
- return CREATE_RECEIPT_ERROR;
- }
-
- dap_chain_datum_tx_add_item(&l_tx, (byte_t*)l_receipt);
-
- if (dap_chain_datum_tx_add_sign_item(&l_tx, l_owner_key) != 1) {
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_owner_addr);
- dap_chain_datum_tx_delete(l_tx);
- DAP_DEL_Z(l_datum_burning_tx);
- log_it(L_ERROR, "Can't add sign output");
- return SIGN_ERROR;
- }
-
- dap_chain_wallet_close(l_wallet);
- DAP_DEL_Z(l_owner_addr);
-
- // Put the transaction to mempool or directly to chains
- l_tx_size = dap_chain_datum_tx_get_size(l_tx);
- if (NULL == (l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size))) {
- dap_chain_datum_tx_delete(l_tx);
- DAP_DEL_Z(l_datum_burning_tx);
- return CREATE_DATUM_ERROR;
- }
-
- dap_chain_datum_tx_delete(l_tx);
-
- if (NULL == (l_datum_hash_str = dap_chain_mempool_datum_add(l_datum_burning_tx, l_chain))) {
- DAP_DEL_Z(l_datum_burning_tx);
- DAP_DEL_Z(l_datum);
- return ADD_DATUM_BURNING_TX_ERROR;
- }
-
- dap_string_append_printf(output_line, "BURNING_TX_DATUM_HASH=%s\n", l_datum_hash_str);
- DAP_DEL_Z(l_datum_burning_tx);
- DAP_DEL_Z(l_datum_hash_str);
-
- // Processing will be made according to autoprocess policy
- if (NULL == (l_datum_hash_str = dap_chain_mempool_datum_add(l_datum, l_chain))) {
- DAP_DEL_Z(l_datum);
- return ADD_DATUM_TX_TAKE_ERROR;
- }
-
- dap_string_append_printf(output_line, "TAKE_TX_DATUM_HASH=%s\n", l_datum_hash_str);
-
- DAP_DEL_Z(l_datum_hash_str);
- DAP_DEL_Z(l_datum);
-
- return STAKE_NO_ERROR;
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_owner_addr);
+ dap_chain_datum_tx_delete(l_tx);
+ DAP_DEL_Z(l_datum_burning_tx);
+ return CREATE_RECEIPT_ERROR;
+ }
+
+ dap_chain_datum_tx_add_item(&l_tx, (byte_t*)l_receipt);
+
+ if (dap_chain_datum_tx_add_sign_item(&l_tx, l_owner_key) != 1) {
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_owner_addr);
+ dap_chain_datum_tx_delete(l_tx);
+ DAP_DEL_Z(l_datum_burning_tx);
+ log_it(L_ERROR, "Can't add sign output");
+ return SIGN_ERROR;
+ }
+
+ dap_chain_wallet_close(l_wallet);
+ DAP_DEL_Z(l_owner_addr);
+
+ // Put the transaction to mempool or directly to chains
+ l_tx_size = dap_chain_datum_tx_get_size(l_tx);
+ if (NULL == (l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size))) {
+ dap_chain_datum_tx_delete(l_tx);
+ DAP_DEL_Z(l_datum_burning_tx);
+ return CREATE_DATUM_ERROR;
+ }
+
+ dap_chain_datum_tx_delete(l_tx);
+
+ if (NULL == (l_datum_hash_str = dap_chain_mempool_datum_add(l_datum_burning_tx, l_chain))) {
+ DAP_DEL_Z(l_datum_burning_tx);
+ DAP_DEL_Z(l_datum);
+ return ADD_DATUM_BURNING_TX_ERROR;
+ }
+
+ dap_string_append_printf(output_line, "BURNING_TX_DATUM_HASH=%s\n", l_datum_hash_str);
+ DAP_DEL_Z(l_datum_burning_tx);
+ DAP_DEL_Z(l_datum_hash_str);
+
+ // Processing will be made according to autoprocess policy
+ if (NULL == (l_datum_hash_str = dap_chain_mempool_datum_add(l_datum, l_chain))) {
+ DAP_DEL_Z(l_datum);
+ return ADD_DATUM_TX_TAKE_ERROR;
+ }
+
+ dap_string_append_printf(output_line, "TAKE_TX_DATUM_HASH=%s\n", l_datum_hash_str);
+
+ DAP_DEL_Z(l_datum_hash_str);
+ DAP_DEL_Z(l_datum);
+
+ return STAKE_NO_ERROR;
}
/**
@@ -583,172 +584,172 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
*/
static void s_error_handler(enum error_code errorCode, dap_string_t* output_line)
{
- dap_string_append_printf(output_line, "ERROR!\n");
- switch (errorCode)
- {
- case NET_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -net");
- } break;
-
- case NET_ERROR: {
+ dap_string_append_printf(output_line, "ERROR!\n");
+ switch (errorCode)
+ {
+ case NET_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -net");
+ } break;
+
+ case NET_ERROR: {
dap_string_append_printf(output_line, "^^^ network not found");
- } break;
+ } break;
- case TOKEN_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -token");
- } break;
+ case TOKEN_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -token");
+ } break;
- case TOKEN_ERROR: {
+ case TOKEN_ERROR: {
dap_string_append_printf(output_line, "^^^ token ticker not found");
- } break;
+ } break;
- case COINS_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -coins");
- } break;
+ case COINS_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -coins");
+ } break;
- case COINS_FORMAT_ERROR: {
- dap_string_append_printf(output_line, "Format -coins <256 bit integer>");
- } break;
+ case COINS_FORMAT_ERROR: {
+ dap_string_append_printf(output_line, "Format -coins <256 bit integer>");
+ } break;
- case ADDR_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -addr_holder");
- } break;
+ case ADDR_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -addr_holder");
+ } break;
- case ADDR_FORMAT_ERROR: {
- dap_string_append_printf(output_line, "wrong address holder format");
- } break;
+ case ADDR_FORMAT_ERROR: {
+ dap_string_append_printf(output_line, "wrong address holder format");
+ } break;
- case CERT_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -cert");
- } break;
+ case CERT_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -cert");
+ } break;
- case CERT_LOAD_ERROR: {
+ case CERT_LOAD_ERROR: {
dap_string_append_printf(output_line, "^^^ can't load cert");
- } break;
+ } break;
- case CHAIN_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command requires parameter '-chain'.\n"
- "you can set default datum type in chain configuration file");
- } break;
+ case CHAIN_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command requires parameter '-chain'.\n"
+ "you can set default datum type in chain configuration file");
+ } break;
- case CHAIN_EMISSION_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command requires parameter '-chain_emission'.\n"
- "you can set default datum type in chain configuration file");
- } break;
+ case CHAIN_EMISSION_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command requires parameter '-chain_emission'.\n"
+ "you can set default datum type in chain configuration file");
+ } break;
- case TIME_ERROR: {
+ case TIME_ERROR: {
dap_string_append_printf(output_line, "stake_ext command requires parameter '-time_staking' in simplified format YYMMDD\n"
"Example: \"220610\" == \"10 june 2022 00:00\"");
- } break;
+ } break;
- case NO_MONEY_ERROR: {
- dap_string_append_printf(output_line, "Not enough money");
- } break;
+ case NO_MONEY_ERROR: {
+ dap_string_append_printf(output_line, "Not enough money");
+ } break;
- case WALLET_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -wallet");
- } break;
+ case WALLET_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -wallet");
+ } break;
- case WALLET_OPEN_ERROR: {
+ case WALLET_OPEN_ERROR: {
dap_string_append_printf(output_line, "^^^ can't open wallet");
- } break;
+ } break;
- case CERT_KEY_ERROR: {
+ case CERT_KEY_ERROR: {
dap_string_append_printf(output_line, "^^^ cert doesn't contain a valid public key");
- } break;
+ } break;
- case WALLET_ADDR_ERROR: {
+ case WALLET_ADDR_ERROR: {
dap_string_append_printf(output_line, "^^^ failed to get wallet address");
- } break;
+ } break;
- case TX_ARG_ERROR: {
- dap_string_append_printf(output_line, "stake_lock command required parameter -tx");
- } break;
+ case TX_ARG_ERROR: {
+ dap_string_append_printf(output_line, "stake_lock command required parameter -tx");
+ } break;
- case HASH_IS_BLANK_ERROR: {
- dap_string_append_printf(output_line, "tx hash is blank");
- } break;
+ case HASH_IS_BLANK_ERROR: {
+ dap_string_append_printf(output_line, "tx hash is blank");
+ } break;
- case NO_TX_ERROR: {
+ case NO_TX_ERROR: {
dap_string_append_printf(output_line, "^^^ could not find transaction");
- } break;
+ } break;
- case STAKE_ERROR: {
- dap_string_append_printf(output_line, "STAKE ERROR");
- } break;
+ case STAKE_ERROR: {
+ dap_string_append_printf(output_line, "STAKE ERROR");
+ } break;
- case NOT_ENOUGH_TIME: {
- dap_string_append_printf(output_line, "Not enough time has passed");
- } break;
+ case NOT_ENOUGH_TIME: {
+ dap_string_append_printf(output_line, "Not enough time has passed");
+ } break;
case TX_TICKER_ERROR: {
dap_string_append_printf(output_line, "ticker not found");
- } break;
+ } break;
- case NO_DELEGATE_TOKEN_ERROR: {
+ case NO_DELEGATE_TOKEN_ERROR: {
dap_string_append_printf(output_line, " ^^^ delegated token not found");
- } break;
+ } break;
- case NO_VALID_SUBTYPE_ERROR: {
- dap_string_append_printf(output_line, "wrong subtype for transaction");
- } break;
+ case NO_VALID_SUBTYPE_ERROR: {
+ dap_string_append_printf(output_line, "wrong subtype for transaction");
+ } break;
- case IS_USED_OUT_ERROR: {
- dap_string_append_printf(output_line, "tx hash is used out");
- } break;
+ case IS_USED_OUT_ERROR: {
+ dap_string_append_printf(output_line, "tx hash is used out");
+ } break;
- case OWNER_KEY_ERROR: {
- dap_string_append_printf(output_line, "key retrieval error");
- } break;
+ case OWNER_KEY_ERROR: {
+ dap_string_append_printf(output_line, "key retrieval error");
+ } break;
- case CREATE_TX_ERROR: {
- dap_string_append_printf(output_line, "memory allocation error when creating a transaction");
- } break;
+ case CREATE_TX_ERROR: {
+ dap_string_append_printf(output_line, "memory allocation error when creating a transaction");
+ } break;
- case CREATE_BURNING_TX_ERROR: {
- dap_string_append_printf(output_line, "failed to create a transaction that burns funds");
- } break;
+ case CREATE_BURNING_TX_ERROR: {
+ dap_string_append_printf(output_line, "failed to create a transaction that burns funds");
+ } break;
- case CREATE_RECEIPT_ERROR: {
- dap_string_append_printf(output_line, "failed to create receipt");
- } break;
+ case CREATE_RECEIPT_ERROR: {
+ dap_string_append_printf(output_line, "failed to create receipt");
+ } break;
- case SIGN_ERROR: {
- dap_string_append_printf(output_line, "failed to sign transaction");
- } break;
+ case SIGN_ERROR: {
+ dap_string_append_printf(output_line, "failed to sign transaction");
+ } break;
- case ADD_DATUM_BURNING_TX_ERROR: {
- dap_string_append_printf(output_line, "failed to add datum with burning-transaction to mempool");
- } break;
+ case ADD_DATUM_BURNING_TX_ERROR: {
+ dap_string_append_printf(output_line, "failed to add datum with burning-transaction to mempool");
+ } break;
- case ADD_DATUM_TX_TAKE_ERROR: {
- dap_string_append_printf(output_line, "failed to add datum with take-transaction to mempool");
- } break;
+ case ADD_DATUM_TX_TAKE_ERROR: {
+ dap_string_append_printf(output_line, "failed to add datum with take-transaction to mempool");
+ } break;
- case BASE_TX_CREATE_ERROR: {
- dap_string_append_printf(output_line, "failed to create the base transaction for emission");
- } break;
+ case BASE_TX_CREATE_ERROR: {
+ dap_string_append_printf(output_line, "failed to create the base transaction for emission");
+ } break;
- case WRONG_PARAM_SIZE: {
- dap_string_append_printf(output_line, "error while checking conditional transaction parameters");
- } break;
+ case WRONG_PARAM_SIZE: {
+ dap_string_append_printf(output_line, "error while checking conditional transaction parameters");
+ } break;
- case CREATE_LOCK_TX_ERROR: {
- dap_string_append_printf(output_line, "error creating transaction");
- } break;
+ case CREATE_LOCK_TX_ERROR: {
+ dap_string_append_printf(output_line, "error creating transaction");
+ } break;
- case CREATE_DATUM_ERROR: {
- dap_string_append_printf(output_line, "error while creating datum from transaction");
- } break;
+ case CREATE_DATUM_ERROR: {
+ dap_string_append_printf(output_line, "error while creating datum from transaction");
+ } break;
case REINVEST_ARG_ERROR: {
dap_string_append_printf(output_line, "reinvestment is set as a percentage from 1 to 100");
} break;
- default: {
- dap_string_append_printf(output_line, "STAKE_LOCK: Unrecognized error");
- } break;
- }
+ default: {
+ dap_string_append_printf(output_line, "STAKE_LOCK: Unrecognized error");
+ } break;
+ }
}
/**
@@ -760,45 +761,45 @@ static void s_error_handler(enum error_code errorCode, dap_string_t* output_line
*/
static int s_cli_stake_lock(int a_argc, char** a_argv, char** a_str_reply)
{
- enum {
- CMD_NONE, CMD_HOLD, CMD_TAKE
- };
+ enum {
+ CMD_NONE, CMD_HOLD, CMD_TAKE
+ };
- enum error_code errorCode;
- int l_arg_index = 1;
- int l_cmd_num = CMD_NONE;
- dap_string_t* output_line = dap_string_new(NULL);
+ enum error_code errorCode;
+ int l_arg_index = 1;
+ int l_cmd_num = CMD_NONE;
+ dap_string_t* output_line = dap_string_new(NULL);
- if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "hold", NULL))
- l_cmd_num = CMD_HOLD;
- else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "take", NULL))
- l_cmd_num = CMD_TAKE;
+ if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "hold", NULL))
+ l_cmd_num = CMD_HOLD;
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "take", NULL))
+ l_cmd_num = CMD_TAKE;
- switch (l_cmd_num) {
+ switch (l_cmd_num) {
- case CMD_HOLD: {
- errorCode = s_cli_hold(a_argc, a_argv, l_arg_index + 1, output_line);
- } break;
+ case CMD_HOLD: {
+ errorCode = s_cli_hold(a_argc, a_argv, l_arg_index + 1, output_line);
+ } break;
- case CMD_TAKE: {
- errorCode = s_cli_take(a_argc, a_argv, l_arg_index + 1, output_line);
- } break;
+ case CMD_TAKE: {
+ errorCode = s_cli_take(a_argc, a_argv, l_arg_index + 1, output_line);
+ } break;
- default: {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
- dap_string_free(output_line, false);
- } return 1;
- }
+ default: {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
+ dap_string_free(output_line, false);
+ } return 1;
+ }
- if (STAKE_NO_ERROR != errorCode)
- s_error_handler(errorCode, output_line);
- else
- dap_string_append_printf(output_line, "Contribution successfully made");
+ if (STAKE_NO_ERROR != errorCode)
+ s_error_handler(errorCode, output_line);
+ else
+ dap_string_append_printf(output_line, "Contribution successfully made");
- dap_cli_server_cmd_set_reply_text(a_str_reply, output_line->str);
- dap_string_free(output_line, true);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, output_line->str);
+ dap_string_free(output_line, true);
- return 0;
+ return 0;
}
/**
@@ -809,49 +810,49 @@ static int s_cli_stake_lock(int a_argc, char** a_argv, char** a_str_reply)
static const char* s_give_month_str_from_month_count(uint8_t month_count)
{
- switch (month_count)
- {
- case 1: {
- return "Jan";
- }
- case 2: {
- return "Feb";
- }
- case 3: {
- return "Mar";
- }
- case 4: {
- return "Apr";
- }
- case 5: {
- return "May";
- }
- case 6: {
- return "Jun";
- }
- case 7: {
- return "Jul";
- }
- case 8: {
- return "Aug";
- }
- case 9: {
- return "Sep";
- }
- case 10: {
- return "Oct";
- }
- case 11: {
- return "Nov";
- }
- case 12: {
- return "Dec";
- }
-
- default: {
- return "";
- }
- }
+ switch (month_count)
+ {
+ case 1: {
+ return "Jan";
+ }
+ case 2: {
+ return "Feb";
+ }
+ case 3: {
+ return "Mar";
+ }
+ case 4: {
+ return "Apr";
+ }
+ case 5: {
+ return "May";
+ }
+ case 6: {
+ return "Jun";
+ }
+ case 7: {
+ return "Jul";
+ }
+ case 8: {
+ return "Aug";
+ }
+ case 9: {
+ return "Sep";
+ }
+ case 10: {
+ return "Oct";
+ }
+ case 11: {
+ return "Nov";
+ }
+ case 12: {
+ return "Dec";
+ }
+
+ default: {
+ return "";
+ }
+ }
}
/**
@@ -861,34 +862,34 @@ static const char* s_give_month_str_from_month_count(uint8_t month_count)
*/
static uint8_t s_give_month_count_from_time_str(char* time)
{
- const uint8_t len_month = 3;
-
- if (!memcmp(&time[MONTH_INDEX], "Jan", len_month))
- return 1;
- else if (!memcmp(&time[MONTH_INDEX], "Feb", len_month))
- return 2;
- else if (!memcmp(&time[MONTH_INDEX], "Mar", len_month))
- return 3;
- else if (!memcmp(&time[MONTH_INDEX], "Apr", len_month))
- return 4;
- else if (!memcmp(&time[MONTH_INDEX], "May", len_month))
- return 5;
- else if (!memcmp(&time[MONTH_INDEX], "Jun", len_month))
- return 6;
- else if (!memcmp(&time[MONTH_INDEX], "Jul", len_month))
- return 7;
- else if (!memcmp(&time[MONTH_INDEX], "Aug", len_month))
- return 8;
- else if (!memcmp(&time[MONTH_INDEX], "Sep", len_month))
- return 9;
- else if (!memcmp(&time[MONTH_INDEX], "Oct", len_month))
- return 10;
- else if (!memcmp(&time[MONTH_INDEX], "Nov", len_month))
- return 11;
- else if (!memcmp(&time[MONTH_INDEX], "Dec", len_month))
- return 12;
- else
- return 0;
+ const uint8_t len_month = 3;
+
+ if (!memcmp(&time[MONTH_INDEX], "Jan", len_month))
+ return 1;
+ else if (!memcmp(&time[MONTH_INDEX], "Feb", len_month))
+ return 2;
+ else if (!memcmp(&time[MONTH_INDEX], "Mar", len_month))
+ return 3;
+ else if (!memcmp(&time[MONTH_INDEX], "Apr", len_month))
+ return 4;
+ else if (!memcmp(&time[MONTH_INDEX], "May", len_month))
+ return 5;
+ else if (!memcmp(&time[MONTH_INDEX], "Jun", len_month))
+ return 6;
+ else if (!memcmp(&time[MONTH_INDEX], "Jul", len_month))
+ return 7;
+ else if (!memcmp(&time[MONTH_INDEX], "Aug", len_month))
+ return 8;
+ else if (!memcmp(&time[MONTH_INDEX], "Sep", len_month))
+ return 9;
+ else if (!memcmp(&time[MONTH_INDEX], "Oct", len_month))
+ return 10;
+ else if (!memcmp(&time[MONTH_INDEX], "Nov", len_month))
+ return 11;
+ else if (!memcmp(&time[MONTH_INDEX], "Dec", len_month))
+ return 12;
+ else
+ return 0;
}
/**
@@ -899,44 +900,44 @@ static uint8_t s_give_month_count_from_time_str(char* time)
*/
static char* s_update_date_by_using_month_count(char* time, uint8_t month_count)
{
- uint8_t current_month;
- int current_year;
- const char* month_str;
- const char* year_str;
-
- if (!time || !month_count)
- return NULL;
- if ((current_month = s_give_month_count_from_time_str(time)) == 0)
- return NULL;
- if ((current_year = atoi(&time[YEAR_INDEX])) <= 0
- || current_year < 22
- || current_year > 99)
- return NULL;
-
-
- for (uint8_t i = 0; i < month_count; i++) {
- if (current_month == 12)
- {
- current_month = 1;
- current_year++;
- }
- else
- current_month++;
- }
-
- month_str = s_give_month_str_from_month_count(current_month);
- year_str = dap_itoa(current_year);
-
- if (*month_str
- && *year_str
- && dap_strlen(year_str) == 2) {
- memcpy(&time[MONTH_INDEX], month_str, 3); // 3 == len month in time RFC822 format
- memcpy(&time[YEAR_INDEX], year_str, 2); // 2 == len year in time RFC822 format
- }
- else
- return NULL;
-
- return time;
+ uint8_t current_month;
+ int current_year;
+ const char* month_str;
+ const char* year_str;
+
+ if (!time || !month_count)
+ return NULL;
+ if ((current_month = s_give_month_count_from_time_str(time)) == 0)
+ return NULL;
+ if ((current_year = atoi(&time[YEAR_INDEX])) <= 0
+ || current_year < 22
+ || current_year > 99)
+ return NULL;
+
+
+ for (uint8_t i = 0; i < month_count; i++) {
+ if (current_month == 12)
+ {
+ current_month = 1;
+ current_year++;
+ }
+ else
+ current_month++;
+ }
+
+ month_str = s_give_month_str_from_month_count(current_month);
+ year_str = dap_itoa(current_year);
+
+ if (*month_str
+ && *year_str
+ && dap_strlen(year_str) == 2) {
+ memcpy(&time[MONTH_INDEX], month_str, 3); // 3 == len month in time RFC822 format
+ memcpy(&time[YEAR_INDEX], year_str, 2); // 2 == len year in time RFC822 format
+ }
+ else
+ return NULL;
+
+ return time;
}
/**
@@ -961,28 +962,28 @@ bool s_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_c
const char *l_tx_ticker;
dap_chain_datum_token_t *delegate_token;
- /*if (!a_owner) TODO: ???
+ /*if (!a_owner) TODO: ???
return false;*/
- if (a_cond->params_size != sizeof(*l_params))// Wrong params size
- return false;
- l_params = (cond_params_t*)a_cond->params;
+ if (a_cond->params_size != sizeof(*l_params))// Wrong params size
+ return false;
+ l_params = (cond_params_t*)a_cond->params;
- if (l_params->flags & DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_BY_TIME) {
- if (l_params->time_unlock > dap_time_now())
- return false;
- }
+ if (l_params->flags & DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_BY_TIME) {
+ if (l_params->time_unlock > dap_time_now())
+ return false;
+ }
l_receipt = (dap_chain_datum_tx_receipt_t *)dap_chain_datum_tx_item_get(a_tx, 0, TX_ITEM_TYPE_RECEIPT, 0);
- if (!l_receipt)
- return false;
+ if (!l_receipt)
+ return false;
#if DAP_CHAIN_NET_SRV_UID_SIZE == 8
- if (l_receipt->receipt_info.srv_uid.uint64 != DAP_CHAIN_NET_SRV_STAKE_LOCK_ID)
- return false;
+ if (l_receipt->receipt_info.srv_uid.uint64 != DAP_CHAIN_NET_SRV_STAKE_LOCK_ID)
+ return false;
#elif DAP_CHAIN_NET_SRV_UID_SIZE == 16
- if (l_receipt->receipt_info.srv_uid.uint128 != DAP_CHAIN_NET_SRV_EXTERNAL_STAKE_ID)
- return false;
+ if (l_receipt->receipt_info.srv_uid.uint128 != DAP_CHAIN_NET_SRV_EXTERNAL_STAKE_ID)
+ return false;
#endif
char delegated_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
@@ -993,13 +994,13 @@ bool s_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_c
return false;
}
- if (dap_hash_fast_is_blank(&hash_burning_transaction))
- return false;
+ if (dap_hash_fast_is_blank(&hash_burning_transaction))
+ return false;
l_tx_out = (dap_chain_tx_out_t *)dap_chain_datum_tx_item_get(a_tx, 0, TX_ITEM_TYPE_OUT,0);
- if (!l_tx_out)
- return false;
+ if (!l_tx_out)
+ return false;
if (!EQUAL_256(a_cond->header.value, l_tx_out->header.value))
return false;
@@ -1023,14 +1024,15 @@ bool s_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_c
return false;
if (NULL == (l_tx_ticker = dap_chain_ledger_tx_get_token_ticker_by_hash(a_ledger, &hash_burning_transaction)))
return false;
- if (strcmp(l_tx_ticker, delegated_ticker))
+ if (strcmp(l_tx_ticker, delegated_ticker)) {
return false;
+ }
- burning_tx = dap_chain_ledger_tx_find_by_hash(a_ledger, &hash_burning_transaction);
- burning_transaction_out = (dap_chain_tx_out_t*)dap_chain_datum_tx_item_get(burning_tx, 0, TX_ITEM_TYPE_OUT, 0);
+ burning_tx = dap_chain_ledger_tx_find_by_hash(a_ledger, &hash_burning_transaction);
+ burning_transaction_out = (dap_chain_tx_out_t*)dap_chain_datum_tx_item_get(burning_tx, 0, TX_ITEM_TYPE_OUT, 0);
- if (!burning_transaction_out)
- return false;
+ if (!burning_transaction_out)
+ return false;
if (!dap_hash_fast_is_blank(&burning_transaction_out->addr.data.hash_fast)) {
if (s_debug_more) {
@@ -1038,7 +1040,7 @@ bool s_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_c
log_it(L_ERROR, "ADDR from burning NOT BLANK: %s", addr_srt);
DAP_DEL_Z(addr_srt);
}
- return false;
+ return false;
}
if (!IS_ZERO_256(l_tsd_section.emission_rate)) {
@@ -1061,9 +1063,9 @@ bool s_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_c
}
if (!EQUAL_256(burning_transaction_out->header.value, l_value_delegated))//MULT
- return false;
+ return false;
- return true;
+ return true;
}
/**
@@ -1075,21 +1077,21 @@ bool s_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_c
*/
bool s_callback_verificator_added(dap_ledger_t * a_ledger,dap_chain_datum_tx_t* a_tx, dap_chain_tx_out_cond_t *a_tx_item)
{
- dap_chain_hash_fast_t* l_key_hash = DAP_NEW_Z(dap_chain_hash_fast_t);
- if (!l_key_hash)
- return false;
- size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
- dap_hash_fast(a_tx, l_tx_size, l_key_hash);
- if (dap_hash_fast_is_blank(l_key_hash)) {
- DAP_DEL_Z(l_key_hash);
- return false;
- }
+ dap_chain_hash_fast_t* l_key_hash = DAP_NEW_Z(dap_chain_hash_fast_t);
+ if (!l_key_hash)
+ return false;
+ size_t l_tx_size = dap_chain_datum_tx_get_size(a_tx);
+ dap_hash_fast(a_tx, l_tx_size, l_key_hash);
+ if (dap_hash_fast_is_blank(l_key_hash)) {
+ DAP_DEL_Z(l_key_hash);
+ return false;
+ }
s_emission_for_stake_lock_item_add(a_ledger, l_key_hash);
- DAP_DEL_Z(l_key_hash);
+ DAP_DEL_Z(l_key_hash);
- return true;
+ return true;
}
/**
@@ -1105,76 +1107,76 @@ bool s_callback_verificator_added(dap_ledger_t * a_ledger,dap_chain_datum_tx_t*
* @return
*/
static dap_chain_datum_t* s_mempool_create(dap_chain_net_t* a_net,
- dap_enc_key_t* a_key_from, dap_pkey_t* a_key_cond,
- const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint256_t a_value, dap_chain_net_srv_uid_t a_srv_uid,
+ dap_enc_key_t* a_key_from, dap_pkey_t* a_key_cond,
+ const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
+ uint256_t a_value, dap_chain_net_srv_uid_t a_srv_uid,
dap_chain_addr_t* a_addr_holder, dap_time_t a_time_staking, uint8_t reinvest)
{
- 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_cond ||
- !a_key_from->priv_key_data || !a_key_from->priv_key_data_size || IS_ZERO_256(a_value))
- return NULL;
-
- // find the transactions from which to take away coins
- uint256_t l_value_transfer = {}; // how many coins to transfer
+ 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_cond ||
+ !a_key_from->priv_key_data || !a_key_from->priv_key_data_size || IS_ZERO_256(a_value))
+ return NULL;
+
+ // find the transactions from which to take away coins
+ 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);
- // where to take coins for service
- dap_chain_addr_t l_addr_from;
- dap_chain_addr_fill_from_key(&l_addr_from, a_key_from, a_net->pub.id);
- // 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,
- &l_addr_from, a_value, &l_value_transfer);
- if (!l_list_used_out) {
- 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
- {
- 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
- {
- uint256_t l_value_pack = {}; // how much coin add to 'out' items
+ // where to take coins for service
+ dap_chain_addr_t l_addr_from;
+ dap_chain_addr_fill_from_key(&l_addr_from, a_key_from, a_net->pub.id);
+ // 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,
+ &l_addr_from, a_value, &l_value_transfer);
+ if (!l_list_used_out) {
+ 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
+ {
+ 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
+ {
+ uint256_t l_value_pack = {}; // how much coin add to 'out' items
dap_chain_tx_out_cond_t* l_tx_out_cond = dap_chain_net_srv_stake_lock_create_cond_out(a_key_cond, a_srv_uid, a_value, a_time_staking, reinvest);
- if (l_tx_out_cond) {
- SUM_256_256(l_value_pack, a_value, &l_value_pack);
- dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*)l_tx_out_cond);
- // DAP_DEL_Z(l_tx_out_cond);
- // transaction fee
- // if (!IS_ZERO_256(a_value_fee)) {
- // TODO add condition with fee for mempool-as-service
- // }
- }//TODO: else return false;
- // coin 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, &l_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;
+ if (l_tx_out_cond) {
+ SUM_256_256(l_value_pack, a_value, &l_value_pack);
+ dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*)l_tx_out_cond);
+ // DAP_DEL_Z(l_tx_out_cond);
+ // transaction fee
+ // if (!IS_ZERO_256(a_value_fee)) {
+ // TODO add condition with fee for mempool-as-service
+ // }
+ }//TODO: else return false;
+ // coin 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, &l_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;
}
/**
@@ -1189,24 +1191,24 @@ static dap_chain_datum_t* s_mempool_create(dap_chain_net_t* a_net,
dap_chain_tx_out_cond_t* dap_chain_net_srv_stake_lock_create_cond_out(dap_pkey_t* a_key, dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value,
uint64_t a_time_staking, uint8_t reinvest)
{
- if (IS_ZERO_256(a_value))
- 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) + sizeof(cond_params_t));
- 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_STAKE_LOCK;
- l_item->header.srv_uid = a_srv_uid;
- l_item->params_size = sizeof(cond_params_t);
- cond_params_t* l_params = (cond_params_t*)l_item->params;
+ if (IS_ZERO_256(a_value))
+ 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) + sizeof(cond_params_t));
+ 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_STAKE_LOCK;
+ l_item->header.srv_uid = a_srv_uid;
+ l_item->params_size = sizeof(cond_params_t);
+ cond_params_t* l_params = (cond_params_t*)l_item->params;
l_params->reinvest = reinvest;
- if (a_time_staking) {
- l_params->time_unlock = dap_time_now() + a_time_staking;
- l_params->flags |= DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_BY_TIME;
- }
- if (a_key)
- dap_hash_fast(a_key->pkey, a_key->header.size, &l_params->pkey_delegated);
-
- return l_item;
+ if (a_time_staking) {
+ l_params->time_unlock = dap_time_now() + a_time_staking;
+ l_params->flags |= DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_BY_TIME;
+ }
+ if (a_key)
+ dap_hash_fast(a_key->pkey, a_key->header.size, &l_params->pkey_delegated);
+
+ return l_item;
}
@@ -1223,105 +1225,105 @@ dap_chain_tx_out_cond_t* dap_chain_net_srv_stake_lock_create_cond_out(dap_pkey_t
* @return
*/
dap_chain_hash_fast_t* dap_chain_net_srv_stake_lock_mempool_create(dap_chain_net_t* a_net,
- dap_enc_key_t* a_key_from, dap_pkey_t* a_key_cond,
- const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint256_t a_value, dap_chain_net_srv_uid_t a_srv_uid,
+ dap_enc_key_t* a_key_from, dap_pkey_t* a_key_cond,
+ const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
+ uint256_t a_value, dap_chain_net_srv_uid_t a_srv_uid,
dap_chain_addr_t* a_addr_holder, uint64_t a_time_staking, uint8_t reinvest)
{
- // Make transfer transaction
- dap_chain_datum_t* l_datum = s_mempool_create(a_net, a_key_from, a_key_cond, a_token_ticker, a_value, a_srv_uid,
+ // Make transfer transaction
+ dap_chain_datum_t* l_datum = s_mempool_create(a_net, a_key_from, a_key_cond, a_token_ticker, a_value, a_srv_uid,
a_addr_holder, a_time_staking, reinvest);
- if (!l_datum)
- return NULL;
+ 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_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_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);
- 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);
+ 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_global_db_set(l_gdb_group, l_key_str, l_datum, dap_chain_datum_size(l_datum), false, NULL, NULL) == true) {
- log_it(L_NOTICE, "Transaction %s placed in mempool group %s", l_key_str, l_gdb_group);
- }
+ if (dap_global_db_set(l_gdb_group, l_key_str, l_datum, dap_chain_datum_size(l_datum), false, NULL, NULL) == true) {
+ log_it(L_NOTICE, "Transaction %s placed in mempool group %s", l_key_str, l_gdb_group);
+ }
- DAP_DELETE(l_gdb_group);
- DAP_DELETE(l_key_str);
+ DAP_DELETE(l_gdb_group);
+ DAP_DELETE(l_key_str);
- return l_key_hash;
+ return l_key_hash;
}
dap_chain_datum_t* dap_chain_burning_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 char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
- uint256_t a_value)
+ const dap_chain_addr_t* a_addr_from, const dap_chain_addr_t* a_addr_to,
+ const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
+ uint256_t a_value)
{
- // 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) || (a_addr_to && !dap_chain_addr_check_sum(a_addr_to)) || IS_ZERO_256(a_value))
- return NULL;
-
- // find the transactions from which to take away coins
- uint256_t l_value_transfer = {}; // how many coins to transfer
- 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, a_value, &l_value_transfer);
- if (!l_list_used_out) {
- log_it(L_WARNING, "Not enough funds to transfer");
- return NULL;
- }
- // create empty transaction
- dap_chain_datum_tx_t* l_tx = dap_chain_datum_tx_create();
- // add 'in' items
- {
- 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
- {
- 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) {
- SUM_256_256(l_value_pack, a_value, &l_value_pack);
- }
- // coin 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;
- }
- }
- }
-
- // 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 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_DELETE(l_tx);
-
- return l_datum;
-
- // dap_hash_fast_t * l_ret = DAP_NEW_Z(dap_hash_fast_t);
- // dap_hash_fast(l_tx, l_tx_size, l_ret);
- // DAP_DELETE(l_tx);
- // char *l_hash_str = dap_chain_mempool_datum_add(l_datum, a_chain);
-
- // DAP_DELETE( l_datum );
- //
- // if (l_hash_str) {
- // DAP_DELETE(l_hash_str);
- // return l_ret;
- // }else{
- // DAP_DELETE(l_ret);
- // return NULL;
- // }
+ // 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) || (a_addr_to && !dap_chain_addr_check_sum(a_addr_to)) || IS_ZERO_256(a_value))
+ return NULL;
+
+ // find the transactions from which to take away coins
+ uint256_t l_value_transfer = {}; // how many coins to transfer
+ 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, a_value, &l_value_transfer);
+ if (!l_list_used_out) {
+ log_it(L_WARNING, "Not enough funds to transfer");
+ return NULL;
+ }
+ // create empty transaction
+ dap_chain_datum_tx_t* l_tx = dap_chain_datum_tx_create();
+ // add 'in' items
+ {
+ 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
+ {
+ 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) {
+ SUM_256_256(l_value_pack, a_value, &l_value_pack);
+ }
+ // coin 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;
+ }
+ }
+ }
+
+ // 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 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_DELETE(l_tx);
+
+ return l_datum;
+
+ // dap_hash_fast_t * l_ret = DAP_NEW_Z(dap_hash_fast_t);
+ // dap_hash_fast(l_tx, l_tx_size, l_ret);
+ // DAP_DELETE(l_tx);
+ // char *l_hash_str = dap_chain_mempool_datum_add(l_datum, a_chain);
+
+ // DAP_DELETE( l_datum );
+ //
+ // if (l_hash_str) {
+ // DAP_DELETE(l_hash_str);
+ // return l_ret;
+ // }else{
+ // DAP_DELETE(l_ret);
+ // return NULL;
+ // }
}
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 361bd35f11..3690f5bb49 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -268,7 +268,7 @@ int dap_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
l_dag->datum_add_hashes_count = dap_config_get_item_uint16_default(a_chain_cfg,"dag","datum_add_hashes_count",1);
char * l_round_new_str = dap_strdup( dap_config_get_item_str_default(a_chain_cfg,"dag","gdb_group_events_round_new", "new"));
dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
-
+
l_dag->broadcast_disable = true;
char *l_gdb_group;
if (!l_dag->is_celled)
@@ -650,6 +650,7 @@ static bool s_chain_callback_datums_pool_proc(dap_chain_t * a_chain, dap_chain_d
dap_chain_cs_dag_event_round_item_t *l_round_item =
DAP_NEW_Z_SIZE(dap_chain_cs_dag_event_round_item_t,
sizeof(dap_chain_cs_dag_event_round_item_t));
+ dap_hash_fast(a_datum, dap_chain_datum_size(a_datum), &l_datum_hash);
l_round_item->round_info.datum_hash = l_datum_hash;
dap_chain_cs_dag_event_calc_hash(l_event,l_event_size, &l_event_hash);
char * l_event_hash_str = dap_chain_hash_fast_to_str_new(&l_event_hash);
@@ -1045,13 +1046,13 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_first(dap_chain_atom_
}
}
if (!found && a_atom_iter->with_treshold) {
- HASH_ITER(hh, l_dag_pvt->events_treshold, l_item_cur, l_item_tmp) {
- if (l_item_cur->event->header.cell_id.uint64 == a_atom_iter->cell_id.uint64) {
- a_atom_iter->cur_item = l_item_cur;
+ HASH_ITER(hh, l_dag_pvt->events_treshold, l_item_cur, l_item_tmp) {
+ if (l_item_cur->event->header.cell_id.uint64 == a_atom_iter->cell_id.uint64) {
+ a_atom_iter->cur_item = l_item_cur;
a_atom_iter->found_in_treshold = 1;
- break;
- }
- }
+ break;
+ }
+ }
}
if ( a_atom_iter->cur_item ){
@@ -1094,7 +1095,7 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_lasts( dap_chain_ato
l_ret[i] = l_event_item->event;
(*a_lasts_size_array)[i] = l_event_item->event_size;
i++;
- }
+ }
}
pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
return l_ret;
--
GitLab