diff --git a/modules/net/dap_chain_ledger.c b/modules/net/dap_chain_ledger.c
index b59f1894a4f24330f60e12903278a50c6bd339fd..5c1ef173ea5bb7446083f1002a4b31aab26f2f39 100644
--- a/modules/net/dap_chain_ledger.c
+++ b/modules/net/dap_chain_ledger.c
@@ -64,7 +64,7 @@ typedef struct dap_ledger_verificator {
int subtype; // hash key
dap_ledger_verificator_callback_t callback;
dap_ledger_updater_callback_t callback_added;
- dap_ledger_updater_callback_t callback_deleted;
+ dap_ledger_delete_callback_t callback_deleted;
UT_hash_handle hh;
} dap_ledger_verificator_t;
@@ -4444,7 +4444,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
pthread_rwlock_unlock(&s_verificators_rwlock);
if (l_verificator && l_verificator->callback_added)
- l_verificator->callback_added(a_ledger, a_tx, l_bound_item->cond);
+ l_verificator->callback_added(a_ledger, a_tx, a_tx_hash, l_bound_item->cond);
} break;
default:
@@ -4497,7 +4497,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
pthread_rwlock_unlock(&s_verificators_rwlock);
if (l_verificator && l_verificator->callback_added)
- l_verificator->callback_added(a_ledger, a_tx, NULL);
+ l_verificator->callback_added(a_ledger, a_tx, a_tx_hash, NULL);
continue; // balance raise will be with next conditional transaction
}
@@ -4650,7 +4650,7 @@ FIN:
return l_ret;
}
-void dap_leger_load_end(dap_ledger_t *a_ledger)
+void dap_ledger_load_end(dap_ledger_t *a_ledger)
{
pthread_rwlock_wrlock(&PVT(a_ledger)->ledger_rwlock);
HASH_SORT(PVT(a_ledger)->ledger_items, s_sort_ledger_tx_item);
@@ -5610,7 +5610,7 @@ dap_list_t *dap_ledger_get_list_tx_outs(dap_ledger_t *a_ledger, const char *a_to
// Add new verificator callback with associated subtype. Returns 1 if callback replaced, -1 error, overwise returns 0
-int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_ledger_verificator_callback_t a_callback, dap_ledger_updater_callback_t a_callback_added, dap_ledger_updater_callback_t a_callback_deleted)
+int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_ledger_verificator_callback_t a_callback, dap_ledger_updater_callback_t a_callback_added, dap_ledger_delete_callback_t a_callback_deleted)
{
dap_ledger_verificator_t *l_new_verificator = NULL;
int l_tmp = (int)a_subtype;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 9fd5effec1b3d730b82298d46d5a686196bdeb97..4456663b507a87187c842020bb185ae984b90dc8 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -2031,9 +2031,8 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
}
if (!l_chain->callback_get_poa_certs)
continue;
- l_net->pub.keys = l_chain->callback_get_poa_certs(l_chain, NULL, NULL);
- if (l_net->pub.keys)
- break;
+ if (!l_net->pub.keys)
+ l_net->pub.keys = l_chain->callback_get_poa_certs(l_chain, NULL, NULL);
}
if (!l_net->pub.keys)
log_it(L_WARNING, "PoA certificates for net %s not found", l_net->pub.name);
@@ -2111,7 +2110,7 @@ bool s_net_load(void *a_arg)
l_chain = l_chain->next;
}
l_net_pvt->load_mode = false;
- dap_leger_load_end(l_net->pub.ledger);
+ dap_ledger_load_end(l_net->pub.ledger);
// Do specific role actions post-chain created
l_net_pvt->state_target = NET_STATE_OFFLINE;
@@ -3221,7 +3220,7 @@ static dap_chain_t *s_switch_sync_chain(dap_chain_net_t *a_net)
l_net_pvt->state = NET_STATE_ONLINE;
s_net_states_proc(a_net);
if(l_prev_state == NET_STATE_SYNC_CHAINS)
- dap_leger_load_end(a_net->pub.ledger);
+ dap_ledger_load_end(a_net->pub.ledger);
return NULL;
}
@@ -3315,7 +3314,7 @@ static bool s_net_states_proc(void *a_arg)
assert(l_net_pvt);
if (l_net_pvt->state_target == NET_STATE_OFFLINE) {
if(l_net_pvt->state == NET_STATE_SYNC_CHAINS)
- dap_leger_load_end(l_net->pub.ledger);
+ dap_ledger_load_end(l_net->pub.ledger);
l_net_pvt->state = NET_STATE_OFFLINE;
}
@@ -3401,4 +3400,4 @@ DAP_INLINE dap_chain_net_state_t dap_chain_net_get_target_state(dap_chain_net_t
return PVT(a_net)->state_target;
}
-/*------------------------------------State machine block end---------------------------------*/
\ No newline at end of file
+/*------------------------------------State machine block end---------------------------------*/
diff --git a/modules/net/include/dap_chain_ledger.h b/modules/net/include/dap_chain_ledger.h
index 6c5c487316371532bc920e335429b1b1a552f555..9074e4dcf58da3255a763fcbac0d874c7d7c9c5e 100644
--- a/modules/net/include/dap_chain_ledger.h
+++ b/modules/net/include/dap_chain_ledger.h
@@ -201,7 +201,8 @@ typedef struct dap_ledger_datum_iter {
} dap_ledger_datum_iter_t;
typedef int (*dap_ledger_verificator_callback_t)(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_tx_out_cond, dap_chain_datum_tx_t *a_tx_in, bool a_owner);
-typedef void (*dap_ledger_updater_callback_t)(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_prev_cond);
+typedef void (*dap_ledger_updater_callback_t)(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx_in, dap_hash_fast_t *a_tx_in_hash, dap_chain_tx_out_cond_t *a_prev_cond);
+typedef void (*dap_ledger_delete_callback_t)(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx_in, dap_chain_tx_out_cond_t *a_prev_cond);
typedef void (* dap_ledger_tx_add_notify_t)(void *a_arg, dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chan_ledger_notify_opcodes_t a_opcode);
typedef void (* dap_ledger_bridged_tx_notify_t)(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_hash_fast_t *a_tx_hash, void *a_arg, dap_chan_ledger_notify_opcodes_t a_opcode);
typedef bool (*dap_ledger_cache_tx_check_callback_t)(dap_ledger_t *a_ledger, dap_hash_fast_t *a_tx_hash);
@@ -433,7 +434,7 @@ dap_list_t *dap_ledger_get_list_tx_cond_outs(dap_ledger_t *a_ledger, const char
dap_chain_tx_out_cond_subtype_t a_subtype, uint256_t *a_value_transfer);
// Add new verificator callback with associated subtype. Returns 1 if callback replaced, overwise returns 0
int dap_ledger_verificator_add(dap_chain_tx_out_cond_subtype_t a_subtype, dap_ledger_verificator_callback_t a_callback,
- dap_ledger_updater_callback_t a_callback_added, dap_ledger_updater_callback_t a_callback_deleted);
+ dap_ledger_updater_callback_t a_callback_added, dap_ledger_delete_callback_t a_callback_deleted);
// Add new verificator callback for voting. Returns 1 if callback replaced, overwise returns 0
int dap_chain_ledger_voting_verificator_add(dap_chain_ledger_voting_callback_t a_callback, dap_chain_ledger_voting_delete_callback_t a_callback_delete);
// Getting a list of transactions from the ledger.
@@ -454,4 +455,4 @@ void dap_ledger_bridged_tx_notify_add(dap_ledger_t *a_ledger, dap_ledger_bridged
bool dap_ledger_cache_enabled(dap_ledger_t *a_ledger);
void dap_ledger_set_cache_tx_check_callback(dap_ledger_t *a_ledger, dap_ledger_cache_tx_check_callback_t a_callback);
dap_chain_tx_out_cond_t* dap_chain_ledger_get_tx_out_cond_linked_to_tx_in_cond(dap_ledger_t *a_ledger, dap_chain_tx_in_cond_t *a_in_cond);
-void dap_leger_load_end(dap_ledger_t *a_ledger);
+void dap_ledger_load_end(dap_ledger_t *a_ledger);
diff --git a/modules/service/stake/dap_chain_net_srv_stake_lock.c b/modules/service/stake/dap_chain_net_srv_stake_lock.c
index 53a216607537db1cbf3f2d8f92c4b1ea1852b6d6..627defb078f38f725e0d69e3f087ef2b7e9cc688 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_lock.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_lock.c
@@ -107,7 +107,7 @@ dap_chain_datum_t *s_stake_unlock_datum_create(dap_chain_net_t *a_net, dap_enc_k
uint256_t a_value_fee,
const char *a_delegated_ticker_str, uint256_t a_delegated_value,int *res);
// Callbacks
-static void s_stake_lock_callback_updater(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_prev_out_item);
+static void s_stake_lock_callback_updater(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx_in, dap_hash_fast_t *a_tx_in_hash, dap_chain_tx_out_cond_t *a_prev_out_item);
static int s_stake_lock_callback_verificator(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_cond, dap_chain_datum_tx_t *a_tx_in, bool a_owner);
static inline int s_tsd_str_cmp(const byte_t *a_tsdata, size_t a_tsdsize, const char *str ) {
@@ -1105,17 +1105,14 @@ static int s_stake_lock_callback_verificator(dap_ledger_t *a_ledger, dap_chain_t
* @param a_tx_item_idx
* @return
*/
-static void s_stake_lock_callback_updater(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_prev_out_item)
+static void s_stake_lock_callback_updater(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx_in, dap_hash_fast_t *a_tx_in_hash, dap_chain_tx_out_cond_t *a_prev_out_item)
{
if (a_prev_out_item) // this is IN_COND tx
return;
int l_out_num = 0;
- dap_chain_tx_out_cond_t *l_cond = dap_chain_datum_tx_out_cond_get(a_tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK, &l_out_num);
- if (l_cond->subtype.srv_stake_lock.flags & DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_CREATE_BASE_TX) {
- dap_chain_hash_fast_t l_tx_cond_hash;
- dap_hash_fast(a_tx, dap_chain_datum_tx_get_size(a_tx), &l_tx_cond_hash);
- dap_ledger_emission_for_stake_lock_item_add(a_ledger, &l_tx_cond_hash);
- }
+ dap_chain_tx_out_cond_t *l_cond = dap_chain_datum_tx_out_cond_get(a_tx_in, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK, &l_out_num);
+ if (l_cond->subtype.srv_stake_lock.flags & DAP_CHAIN_NET_SRV_STAKE_LOCK_FLAG_CREATE_BASE_TX)
+ dap_ledger_emission_for_stake_lock_item_add(a_ledger, a_tx_in_hash);
}
static dap_chain_datum_t *s_stake_lock_datum_create(dap_chain_net_t *a_net, dap_enc_key_t *a_key_from,
diff --git a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
index 2efa8490bfb650e3268f9e8e8e4595c6a79d508c..6ae42e529b82481abac1dc6d1753efeff1f19e62 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
@@ -50,7 +50,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply);
static int s_stake_verificator_callback(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_cond,
dap_chain_datum_tx_t *a_tx_in, bool a_owner);
-static void s_stake_updater_callback(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_cond);
+static void s_stake_updater_callback(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx_in, dap_hash_fast_t *a_tx_in_hash, dap_chain_tx_out_cond_t *a_cond);
static void s_stake_deleted_callback(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_cond);
@@ -105,33 +105,34 @@ int dap_chain_net_srv_stake_pos_delegate_init()
" [-addr <for_tax_collecting>] [-cert <for_order_signing>] [-H {hex(default) | base58}]\n"
"\tCreates an order allowing the validator to delegate it's key with specified params\n"
"srv_stake order update -net <net_name> -order <order_hash> [-params]\n"
- "\tUpdates an order with specified hash\n"
+ "\tUpdates an order with specified hash\n"
"srv_stake order list [fee | validator | staker] -net <net_name>\n"
- "\tGet orders list of specified type within specified net name\n"
+ "\tGet orders list of specified type within specified net name\n"
"srv_stake order remove -net <net_name> -order <order_hash>\n"
- "\tRemove order with specified hash\n"
+ "\tRemove order with specified hash\n"
"\t\t === Commands for work with stake delegate ===\n"
"srv_stake delegate {-cert <pub_cert_name> -value <datoshi> | "
"-order <order_hash> {[-tax_addr <wallet_addr_for_tax_collecting>] | "
"-cert <priv_cert_name> [-node_addr <for_validator_node>]}}"
" -net <net_name> -w <wallet_name> -fee <value>\n"
- "\tDelegate public key in specified certificate or order with specified net name. Pay with specified value of m-tokens of native net token.\n"
- "srv_stake invalidate -net <net_name> {-tx <transaction_hash> | -cert <delegated_cert> | -siging_pkey_hash <pkey_hash> -signing_pkey_type <pkey_type>}"
- " {-w <wallet_name> -fee <value> | -poa_cert <cert_name>}\n"
- "\tInvalidate requested delegated stake transaction by hash or cert name or cert pkey hash within net name and"
- " return m-tokens to specified wallet (if any)\n"
+ "\tDelegate public key in specified certificate or order with specified net name. Pay with specified value of m-tokens of native net token.\n"
+ "srv_stake update -net <net_name> {-tx <transaction_hash> | -cert <delegated_cert>} -w <wallet_name> -value <new_delegation_value> -fee <value>\n"
+ "\tUpdate public key delegation value for specified certificate or transaction hash with specified net name. Pay or cacheback the difference of m-tokens of native net token.\n"
+ "srv_stake invalidate -net <net_name> {-tx <transaction_hash> -w <wallet_name> -fee <value> | -siging_pkey_hash <pkey_hash> -signing_pkey_type <pkey_type> -poa_cert <cert_name>}\n"
+ "\tInvalidate requested delegated stake transaction by hash or cert name or cert pkey hash within net name and"
+ " return m-tokens to specified wallet (if any)\n"
"srv_stake approve -net <net_name> -tx <transaction_hash> -poa_cert <priv_cert_name>\n"
- "\tApprove stake transaction by root node certificate within specified net name\n"
+ "\tApprove stake transaction by root node certificate within specified net name\n"
"srv_stake list keys -net <net_name> [-cert <delegated_cert> | -pkey <pkey_hash_str>]\n"
- "\tShow the list of active stake keys (optional delegated with specified cert).\n"
+ "\tShow the list of active stake keys (optional delegated with specified cert).\n"
"srv_stake list tx -net <net_name> \n"
- "\tShow the list of key delegation transactions.\n"
+ "\tShow the list of key delegation transactions.\n"
"srv_stake min_value -net <net_name> [-chain <chain_name>] -poa_cert <poa_cert_name> -value <value>\n"
- "\tSets the minimum stake value\n"
+ "\tSets the minimum stake value\n"
"srv_stake max_weight -net <net_name> [-chain <chain_name>] -poa_cert <poa_cert_name> -percent <value>\n"
"\tSets maximum validator related weight (in percent)\n"
"srv_stake check -net <net_name> -tx <tx_hash>\n"
- "\tCheck remote validator"
+ "\tCheck remote validator"
);
dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_STAKE_POS_DELEGATE_ID };
@@ -202,75 +203,119 @@ void dap_chain_net_srv_stake_pos_delegate_deinit()
static int s_stake_verificator_callback(dap_ledger_t *a_ledger, dap_chain_tx_out_cond_t *a_cond,
dap_chain_datum_tx_t *a_tx_in, bool a_owner)
{
+ dap_return_val_if_fail(a_ledger && a_cond && a_tx_in, -1);
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(a_ledger->net->pub.id);
- dap_return_val_if_fail(l_srv_stake, -1);
+ dap_return_val_if_fail(l_srv_stake, -2);
+
+#define m_cond_check() \
+( \
+ { \
+ if (l_tx_new_cond->header.subtype != a_cond->header.subtype || \
+ l_tx_new_cond->header.ts_expires != a_cond->header.ts_expires || \
+ !dap_chain_net_srv_uid_compare(l_tx_new_cond->header.srv_uid, \
+ a_cond->header.srv_uid) \
+ ) { \
+ log_it(L_WARNING, "Conditional out and conditional in have different headers"); \
+ return -3; \
+ } \
+ if (l_tx_new_cond->tsd_size != a_cond->tsd_size || \
+ memcmp(l_tx_new_cond->tsd, a_cond->tsd, a_cond->tsd_size)) { \
+ log_it(L_WARNING, "Conditional out and conditional in have different TSD sections"); \
+ return -4; \
+ } \
+ if (dap_chain_addr_is_blank(&l_tx_new_cond->subtype.srv_stake_pos_delegate.signing_addr) || \
+ l_tx_new_cond->subtype.srv_stake_pos_delegate.signer_node_addr.uint64 == 0) { \
+ log_it(L_WARNING, "Not blank address or key fields in order conditional tx"); \
+ return -5; \
+ } \
+ } \
+)
+ int l_out_idx = 0;
+ dap_chain_tx_out_cond_t *l_tx_new_cond = dap_chain_datum_tx_out_cond_get(
+ a_tx_in, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, &l_out_idx);
// It's a order conditional TX
if (dap_chain_addr_is_blank(&a_cond->subtype.srv_stake_pos_delegate.signing_addr) ||
a_cond->subtype.srv_stake_pos_delegate.signer_node_addr.uint64 == 0) {
if (a_owner)
return 0;
- int l_out_idx = 0;
- dap_chain_tx_out_cond_t *l_tx_out_cond = dap_chain_datum_tx_out_cond_get(a_tx_in, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, &l_out_idx);
- if (!l_tx_out_cond) {
+ if (!l_tx_new_cond) {
log_it(L_ERROR, "Condition not found in conditional tx");
- return -2;
- }
- if (compare256(l_tx_out_cond->header.value, a_cond->header.value)) {
- char *l_in_value = dap_chain_balance_to_coins(l_tx_out_cond->header.value);
- char *l_out_value = dap_chain_balance_to_coins(a_cond->header.value);
- log_it(L_WARNING, "In value %s is not equal to out value %s", l_in_value, l_out_value);
- DAP_DELETE(l_in_value);
- DAP_DELETE(l_out_value);
- return -3;
- }
- if (l_tx_out_cond->tsd_size != a_cond->tsd_size ||
- memcmp(l_tx_out_cond->tsd, a_cond->tsd, a_cond->tsd_size)) {
- log_it(L_WARNING, "Conditional out and conditional in have different TSD sections");
- return -4;
+ return -13;
}
- if (dap_chain_addr_is_blank(&l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr) ||
- l_tx_out_cond->subtype.srv_stake_pos_delegate.signer_node_addr.uint64 == 0) {
- log_it(L_WARNING, "Not blank address or key fields in order conditional tx");
- return -5;
+ m_cond_check();
+
+ if (compare256(l_tx_new_cond->header.value, a_cond->header.value)) {
+ log_it(L_WARNING, "Conditional out and conditional in have different values");
+ return -14;
}
return 0;
}
- // It's a delegation conitional TX
- dap_chain_tx_in_cond_t *l_tx_in_cond = (dap_chain_tx_in_cond_t *)dap_chain_datum_tx_item_get(a_tx_in, NULL, NULL, TX_ITEM_TYPE_IN_COND, NULL);
- if (!l_tx_in_cond) {
- log_it(L_ERROR, "Conditional in item not found in checking tx");
- return -6;
- }
- // ATTENTION: It's correct only with single IN_COND TX item
- dap_hash_fast_t *l_prev_hash = &l_tx_in_cond->header.tx_prev_hash;
- if (dap_hash_fast_is_blank(l_prev_hash)) {
- log_it(L_ERROR, "Blank hash of prev tx in tx_in_cond");
- return -7;
- }
if (!a_owner) {
- log_it(L_WARNING, "Trying to spend conditional tx not by owner");
+ log_it(L_WARNING, "Trying to spend conditional tx by not a owner");
return -11;
}
- if (a_tx_in->header.ts_created < 1706227200) // Jan 26 2024 00:00:00 GMT, old policy rules
- return 0;
- dap_chain_net_srv_stake_item_t *l_stake = NULL;
- HASH_FIND(ht, l_srv_stake->tx_itemlist, l_prev_hash, sizeof(dap_hash_t), l_stake);
- if (l_stake) {
- log_it(L_WARNING, "Key is active with delegation decree, need to revoke it first");
- return -12;
+ // Delegation value update (dynamic weight feature)
+ if (l_tx_new_cond) {
+
+ m_cond_check();
+
+ if (!dap_chain_addr_compare(&l_tx_new_cond->subtype.srv_stake_pos_delegate.signing_addr,
+ &a_cond->subtype.srv_stake_pos_delegate.signing_addr)) {
+ log_it(L_WARNING, "Conditional out and conditional in have different signer key hashes");
+ return -15;
+ }
+ if (l_tx_new_cond->subtype.srv_stake_pos_delegate.signer_node_addr.uint64 !=
+ a_cond->subtype.srv_stake_pos_delegate.signer_node_addr.uint64) {
+ log_it(L_WARNING, "Conditional out and conditional in have different node addresses");
+ return -16;
+ }
+ if (compare256(l_tx_new_cond->header.value,
+ dap_chain_net_srv_stake_get_allowed_min_value(a_ledger->net->pub.id)) == -1) {
+ log_it(L_WARNING, "New conditional out have value %s lower than minimum service required",
+ dap_uint256_to_char(l_tx_new_cond->header.value, NULL));
+ return -17;
+ }
+ } else {
+ // It's a delegation conitional TX
+ dap_chain_tx_in_cond_t *l_tx_in_cond = (dap_chain_tx_in_cond_t *)
+ dap_chain_datum_tx_item_get(a_tx_in, NULL, NULL, TX_ITEM_TYPE_IN_COND, NULL);
+ if (!l_tx_in_cond) {
+ log_it(L_ERROR, "Conditional in item not found in current tx");
+ return -6;
+ }
+ // ATTENTION: It's correct only with single IN_COND TX item
+ dap_hash_fast_t *l_prev_hash = &l_tx_in_cond->header.tx_prev_hash;
+ if (dap_hash_fast_is_blank(l_prev_hash)) {
+ log_it(L_ERROR, "Blank hash of prev tx in tx_in_cond");
+ return -7;
+ }
+ if (a_tx_in->header.ts_created < 1706227200) // Jan 26 2024 00:00:00 GMT, old policy rules
+ return 0;
+ dap_chain_net_srv_stake_item_t *l_stake = NULL;
+ HASH_FIND(ht, l_srv_stake->tx_itemlist, l_prev_hash, sizeof(dap_hash_t), l_stake);
+ if (l_stake) {
+ log_it(L_WARNING, "Key %s is empowered for now, need to revoke it first",
+ dap_hash_fast_to_str_static(&l_stake->signing_addr.data.hash_fast));
+ return -12;
+ }
}
return 0;
}
-static void s_stake_updater_callback(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_cond)
+static void s_stake_updater_callback(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx_in, dap_hash_fast_t *a_tx_in_hash, dap_chain_tx_out_cond_t *a_cond)
{
+ dap_return_if_fail(a_ledger && a_tx_in);
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(a_ledger->net->pub.id);
dap_return_if_fail(l_srv_stake);
if (!a_cond)
return;
+ dap_chain_tx_out_cond_t *l_tx_new_cond = dap_chain_datum_tx_out_cond_get(a_tx_in, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, NULL);
dap_chain_addr_t *l_signing_addr = &a_cond->subtype.srv_stake_pos_delegate.signing_addr;
- dap_chain_net_srv_stake_key_invalidate(l_signing_addr);
- s_cache_data(a_ledger, a_tx, l_signing_addr);
+ if (l_tx_new_cond)
+ dap_chain_net_srv_stake_key_update(l_signing_addr, l_tx_new_cond->header.value, a_tx_in_hash);
+ else
+ dap_chain_net_srv_stake_key_invalidate(l_signing_addr);
+ s_cache_data(a_ledger, a_tx_in, l_signing_addr);
}
static void s_stake_deleted_callback(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_chain_tx_out_cond_t *a_cond)
@@ -327,6 +372,7 @@ static bool s_weights_truncate(dap_chain_net_srv_stake_t *l_srv_stake, const uin
}
return l_exceeds_count;
}
+#undef LIMIT_DELTA
static void s_stake_recalculate_weights(dap_chain_net_id_t a_net_id)
{
@@ -384,35 +430,49 @@ void dap_chain_net_srv_stake_key_delegate(dap_chain_net_t *a_net, dap_chain_addr
}
}
dap_chain_esbocs_add_validator_to_clusters(a_net->pub.id, a_node_addr);
- char l_key_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_chain_hash_fast_to_str(&a_signing_addr->data.hash_fast,
- l_key_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
const char *l_value_str; dap_uint256_to_char(a_value, &l_value_str);
- log_it(L_NOTICE, "Added key with fingerprint %s and locked value %s for node "NODE_ADDR_FP_STR,
- l_key_hash_str, l_value_str, NODE_ADDR_FP_ARGS(a_node_addr));
+ log_it(L_NOTICE, "Added key with fingerprint %s and locked value %s for node " NODE_ADDR_FP_STR,
+ dap_chain_hash_fast_to_str_static(&a_signing_addr->data.hash_fast), l_value_str, NODE_ADDR_FP_ARGS(a_node_addr));
s_stake_recalculate_weights(a_signing_addr->net_id);
}
void dap_chain_net_srv_stake_key_invalidate(dap_chain_addr_t *a_signing_addr)
{
- if (!a_signing_addr)
- return;
+ dap_return_if_fail(a_signing_addr);
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(a_signing_addr->net_id);
dap_return_if_fail(l_srv_stake);
dap_chain_net_srv_stake_item_t *l_stake = NULL;
HASH_FIND(hh, l_srv_stake->itemlist, &a_signing_addr->data.hash_fast, sizeof(dap_hash_fast_t), l_stake);
- if (l_stake) {
- dap_chain_esbocs_remove_validator_from_clusters(l_stake->signing_addr.net_id, &l_stake->node_addr);
- HASH_DEL(l_srv_stake->itemlist, l_stake);
- HASH_DELETE(ht, l_srv_stake->tx_itemlist, l_stake);
- char l_key_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
- dap_chain_hash_fast_to_str(&a_signing_addr->data.hash_fast,
- l_key_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
- const char *l_value_str; dap_uint256_to_char(l_stake->locked_value, &l_value_str);
- log_it(L_NOTICE, "Removed key with fingerprint %s and locked value %s for node "NODE_ADDR_FP_STR,
- l_key_hash_str, l_value_str, NODE_ADDR_FP_ARGS_S(l_stake->node_addr));
- DAP_DELETE(l_stake);
- }
+ dap_return_if_fail(l_stake);
+ dap_chain_esbocs_remove_validator_from_clusters(l_stake->signing_addr.net_id, &l_stake->node_addr);
+ HASH_DEL(l_srv_stake->itemlist, l_stake);
+ HASH_DELETE(ht, l_srv_stake->tx_itemlist, l_stake);
+ const char *l_value_str; dap_uint256_to_char(l_stake->locked_value, &l_value_str);
+ log_it(L_NOTICE, "Removed key with fingerprint %s and locked value %s for node " NODE_ADDR_FP_STR,
+ dap_chain_hash_fast_to_str_static(&a_signing_addr->data.hash_fast), l_value_str, NODE_ADDR_FP_ARGS_S(l_stake->node_addr));
+ DAP_DELETE(l_stake);
+ s_stake_recalculate_weights(a_signing_addr->net_id);
+}
+
+void dap_chain_net_srv_stake_key_update(dap_chain_addr_t *a_signing_addr, uint256_t a_new_value, dap_hash_fast_t *a_new_tx_hash)
+{
+ dap_return_if_fail(a_signing_addr && a_new_tx_hash);
+ dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(a_signing_addr->net_id);
+ dap_return_if_fail(l_srv_stake);
+ dap_chain_net_srv_stake_item_t *l_stake = NULL;
+ HASH_FIND(hh, l_srv_stake->itemlist, &a_signing_addr->data.hash_fast, sizeof(dap_hash_fast_t), l_stake);
+ if (!l_stake)
+ return; // It's update for non delegated key, it's OK
+ HASH_DELETE(ht, l_srv_stake->tx_itemlist, l_stake);
+ l_stake->locked_value = l_stake->value = a_new_value;
+ l_stake->tx_hash = *a_new_tx_hash;
+ HASH_ADD(ht, l_srv_stake->tx_itemlist, tx_hash, sizeof(dap_hash_fast_t), l_stake);
+ char *l_old_value_str = dap_chain_balance_to_coins(l_stake->locked_value);
+ const char *l_new_value_str; dap_uint256_to_char(a_new_value, &l_new_value_str);
+ log_it(L_NOTICE, "Updated key with fingerprint %s and locked value %s to new locked value %s for node " NODE_ADDR_FP_STR,
+ dap_chain_hash_fast_to_str_static(&a_signing_addr->data.hash_fast), l_old_value_str,
+ l_new_value_str, NODE_ADDR_FP_ARGS_S(l_stake->node_addr));
+ DAP_DELETE(l_old_value_str);
s_stake_recalculate_weights(a_signing_addr->net_id);
}
@@ -423,7 +483,7 @@ void dap_chain_net_srv_stake_set_allowed_min_value(dap_chain_net_id_t a_net_id,
l_srv_stake->delegate_allowed_min = a_value;
for (dap_chain_net_srv_stake_item_t *it = l_srv_stake->itemlist; it; it = it->hh.next)
if (dap_hash_fast_is_blank(&it->tx_hash))
- it->value = a_value;
+ it->locked_value = it->value = a_value;
}
void dap_chain_net_srv_stake_set_percent_max(dap_chain_net_id_t a_net_id, uint256_t a_value)
@@ -655,7 +715,7 @@ static dap_chain_datum_tx_t *s_stake_tx_create(dap_chain_net_t * a_net, dap_enc_
&l_owner_addr, a_value, &l_value_transfer);
if (!l_list_used_out) {
log_it(L_WARNING, "Nothing to pay for delegate (not enough funds)");
- return NULL;
+ goto tx_fail;
}
// add 'in' items to pay for delegate
uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
@@ -741,6 +801,134 @@ tx_fail:
return NULL;
}
+// Updates staker's funds with delegated key
+static dap_chain_datum_tx_t *s_stake_tx_update(dap_chain_net_t *a_net, dap_hash_fast_t *a_prev_tx_hash, uint256_t a_new_value, uint256_t a_fee, dap_enc_key_t *a_key)
+{
+ dap_return_val_if_fail(a_net && a_key && a_prev_tx_hash && !IS_ZERO_256(a_new_value), NULL);
+
+ const char *l_native_ticker = a_net->pub.native_ticker;
+ char l_delegated_ticker[DAP_CHAIN_TICKER_SIZE_MAX];
+ dap_chain_datum_token_get_delegated_ticker(l_delegated_ticker, l_native_ticker);
+ dap_ledger_t *l_ledger = dap_ledger_by_net_name(a_net->pub.name);
+ uint256_t l_value_transfer = {}, l_fee_transfer = {}; // how many coins to transfer
+ // list of transaction with 'out' items to sell
+ dap_chain_addr_t l_owner_addr;
+ dap_chain_addr_fill_from_key(&l_owner_addr, a_key, a_net->pub.id);
+ uint256_t l_net_fee, l_fee_total = a_fee;
+ dap_chain_addr_t l_net_fee_addr;
+ bool l_net_fee_used = dap_chain_net_tx_get_fee(a_net->pub.id, &l_net_fee, &l_net_fee_addr);
+ if (l_net_fee_used)
+ SUM_256_256(l_fee_total, l_net_fee, &l_fee_total);
+ dap_list_t *l_list_fee_out = dap_ledger_get_list_tx_outs_with_val(l_ledger, l_native_ticker,
+ &l_owner_addr, l_fee_total, &l_fee_transfer);
+ if (!l_list_fee_out) {
+ log_it(L_WARNING, "Nothing to pay for fee (not enough funds)");
+ return NULL;
+ }
+ dap_chain_datum_tx_t *l_tx_prev = dap_ledger_tx_find_by_hash(l_ledger, a_prev_tx_hash);
+ if (!l_tx_prev) {
+ log_it(L_ERROR, "Transaction %s not found", dap_hash_fast_to_str_static(a_prev_tx_hash));
+ return NULL;
+ }
+ int l_out_num = 0;
+ dap_chain_tx_out_cond_t *l_cond_prev = dap_chain_datum_tx_out_cond_get(l_tx_prev, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, &l_out_num);
+ if (!l_cond_prev) {
+ log_it(L_ERROR, "Transaction %s is invalid", dap_hash_fast_to_str_static(a_prev_tx_hash));
+ return NULL;
+ }
+
+ // create empty transaction
+ dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
+
+ // add 'in' item to buy from conditional transaction
+ if (1 != dap_chain_datum_tx_add_in_cond_item(&l_tx, a_prev_tx_hash, l_out_num, -1)) {
+ log_it(L_ERROR, "Can't compose the transaction conditional input");
+ goto tx_fail;
+ }
+
+ // add 'in' items to pay fee
+ uint256_t l_value_fee_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_fee_out);
+ dap_list_free_full(l_list_fee_out, NULL);
+ if (!EQUAL_256(l_value_fee_items, l_fee_transfer)) {
+ log_it(L_ERROR, "Can't compose the fee transaction input");
+ goto tx_fail;
+ }
+ uint256_t l_value_prev = l_cond_prev->header.value, l_value_back = {};
+ bool l_increasing = compare256(a_new_value, l_value_prev) == 1;
+ if (l_increasing) {
+ uint256_t l_refund_value = {};
+ SUBTRACT_256_256(a_new_value, l_value_prev, &l_refund_value);
+ dap_list_t *l_list_used_out = dap_ledger_get_list_tx_outs_with_val(l_ledger, l_delegated_ticker,
+ &l_owner_addr, l_refund_value, &l_value_transfer);
+ if (!l_list_used_out) {
+ log_it(L_WARNING, "Nothing to pay for delegate (not enough funds)");
+ return NULL;
+ }
+ // add 'in' items to pay for delegate
+ uint256_t l_value_to_items = dap_chain_datum_tx_add_in_item_list(&l_tx, l_list_used_out);
+ dap_list_free_full(l_list_used_out, NULL);
+ if (!EQUAL_256(l_value_to_items, l_value_transfer)) {
+ log_it(L_ERROR, "Can't compose the transaction input");
+ goto tx_fail;
+ }
+ SUBTRACT_256_256(l_value_transfer, l_refund_value, &l_value_back);
+ } else
+ SUBTRACT_256_256(l_value_prev, a_new_value, &l_value_back);
+
+ // add 'out_cond' & 'out_ext' items
+ dap_chain_tx_out_cond_t *l_out_cond = DAP_DUP_SIZE(l_cond_prev, sizeof(dap_chain_tx_out_cond_t) + l_cond_prev->tsd_size);
+ if (!l_out_cond) {
+ log_it(L_CRITICAL, "%s", c_error_memory_alloc);
+ goto tx_fail;
+ }
+ l_out_cond->header.value = a_new_value;
+ dap_chain_datum_tx_add_item(&l_tx, (const uint8_t *)l_out_cond);
+ DAP_DELETE(l_out_cond);
+
+ // coin back
+ if (!IS_ZERO_256(l_value_back)) {
+ if (dap_chain_datum_tx_add_out_ext_item(&l_tx, &l_owner_addr, l_value_back, l_delegated_ticker) != 1) {
+ log_it(L_ERROR, "Cant add coin back output");
+ goto tx_fail;
+ }
+ }
+
+ // add fee items
+ if (l_net_fee_used) {
+ if (dap_chain_datum_tx_add_out_ext_item(&l_tx, &l_net_fee_addr, l_net_fee, l_native_ticker) != 1) {
+ log_it(L_ERROR, "Cant add net fee output");
+ goto tx_fail;
+ }
+ }
+ if (!IS_ZERO_256(a_fee)) {
+ if (dap_chain_datum_tx_add_fee_item(&l_tx, a_fee) != 1) {
+ log_it(L_ERROR, "Cant add validator fee output");
+ goto tx_fail;
+ }
+ }
+ uint256_t l_fee_back = {};
+ // fee coin back
+ SUBTRACT_256_256(l_fee_transfer, l_fee_total, &l_fee_back);
+ if (!IS_ZERO_256(l_fee_back)) {
+ if (dap_chain_datum_tx_add_out_ext_item(&l_tx, &l_owner_addr, l_fee_back, l_native_ticker) != 1) {
+ log_it(L_ERROR, "Cant add fee back output");
+ goto tx_fail;
+ }
+ }
+
+ // add 'sign' item
+ if (dap_chain_datum_tx_add_sign_item(&l_tx, a_key) != 1) {
+ log_it(L_ERROR, "Can't add sign output");
+ goto tx_fail;
+ }
+
+ return l_tx;
+
+tx_fail:
+ dap_chain_datum_tx_delete(l_tx);
+ return NULL;
+}
+
static dap_chain_datum_tx_t *s_order_tx_create(dap_chain_net_t * a_net, dap_enc_key_t *a_key,
uint256_t a_value, uint256_t a_fee,
uint256_t a_sovereign_tax, dap_chain_addr_t *a_sovereign_addr)
@@ -799,10 +987,6 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
log_it(L_WARNING, "Requested conditional transaction have another ticker (not %s)", l_delegated_ticker);
return NULL;
}
- if (compare256(l_tx_out_cond->header.value, dap_chain_net_srv_stake_get_allowed_min_value(a_net->pub.id)) == -1) {
- log_it(L_WARNING, "Requested conditional transaction have not enough funds");
- return NULL;
- }
if(dap_chain_net_srv_stake_verify_key_and_node(&l_tx_out_cond->subtype.srv_stake_pos_delegate.signing_addr, &l_tx_out_cond->subtype.srv_stake_pos_delegate.signer_node_addr)){
log_it(L_WARNING, "Key and node verification error");
@@ -1896,7 +2080,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
uint256_t l_allowed_min = dap_chain_net_srv_stake_get_allowed_min_value(l_net->pub.id);
if (compare256(l_value, l_allowed_min) == -1) {
const char *l_coin_min_str, *l_value_min_str = dap_uint256_to_char(l_allowed_min, &l_coin_min_str);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Number in '-value' param %s is lower than minimum allowed value %s(%s)",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Number in '-value' param %s is lower than service minimum allowed value %s(%s)",
l_value_str, l_coin_min_str, l_value_min_str);
dap_enc_key_delete(l_enc_key);
return -11;
@@ -1931,13 +2115,149 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
return 0;
}
+static int s_cli_srv_stake_update(int a_argc, char **a_argv, int a_arg_index, void **a_str_reply, const char *a_hash_out_type)
+{
+ const char *l_net_str = NULL,
+ *l_wallet_str = NULL,
+ *l_value_str,
+ *l_fee_str = NULL,
+ *l_tx_hash_str = NULL,
+ *l_cert_str = NULL;
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str);
+ if (!l_net_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'update' requires parameter -net");
+ return -3;
+ }
+ dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
+ if (!l_net) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ return -4;
+ }
+ uint256_t l_fee = {};
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-w", &l_wallet_str);
+ if (!l_wallet_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'update' requires parameter -w");
+ return -17;
+ }
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-fee", &l_fee_str);
+ if (!l_fee_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'update' requires parameter -fee");
+ return -5;
+ }
+ l_fee = dap_chain_balance_scan(l_fee_str);
+ if (IS_ZERO_256(l_fee)) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Unrecognized number in '-fee' param");
+ return -6;
+ }
+ uint256_t l_value = {};
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-value", &l_value_str);
+ if (!l_value_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'update' requires parameter -value");
+ return -7;
+ }
+ l_value = dap_chain_balance_scan(l_value_str);
+ if (IS_ZERO_256(l_value)) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Unrecognized number in '-value' param");
+ return -8;
+ }
+ uint256_t l_value_min = dap_chain_net_srv_stake_get_allowed_min_value(l_net->pub.id);
+ if (compare256(l_value, l_value_min) == -1) {
+ const char *l_value_min_str; dap_uint256_to_char(l_value_min, &l_value_min_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "New delegation value should be not less than service required minimum %s", l_value_min_str);
+ return -25;
+ }
+
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-tx", &l_tx_hash_str);
+ if (!l_tx_hash_str) {
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str);
+ if (!l_cert_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'update' requires parameter -tx or -cert");
+ return -13;
+ }
+ }
+ dap_hash_fast_t l_tx_hash = {};
+ if (l_tx_hash_str) {
+ dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash);
+ } else {
+ dap_chain_addr_t l_signing_addr;
+ dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
+ if (!l_cert) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate not found");
+ return -18;
+ }
+ if (!l_cert->enc_key->priv_key_data || l_cert->enc_key->priv_key_data_size == 0) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "It is not possible to update a stake using a public key.");
+ return -31;
+ }
+ if (dap_chain_addr_fill_from_key(&l_signing_addr, l_cert->enc_key, l_net->pub.id)) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate is wrong");
+ return -22;
+ }
+ dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(l_net->pub.id);
+ if (!l_srv_stake) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified net have no stake service activated");
+ return -25;
+ }
+ dap_chain_net_srv_stake_item_t *l_stake = NULL;
+ HASH_FIND(hh, l_srv_stake->itemlist, &l_signing_addr.data.hash_fast, sizeof(dap_hash_fast_t), l_stake);
+ if (!l_stake) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate/pkey hash is not delegated nor this delegating is approved."
+ " Try to update with tx hash instead");
+ return -24;
+ }
+ l_tx_hash = l_stake->tx_hash;
+ }
+
+ const char *l_tx_hash_str_tmp = l_tx_hash_str ? l_tx_hash_str : dap_hash_fast_to_str_static(&l_tx_hash);
+ dap_chain_datum_tx_t *l_tx = dap_ledger_tx_find_by_hash(l_net->pub.ledger, &l_tx_hash);
+ if (!l_tx) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s not found", l_tx_hash_str_tmp);
+ return -21;
+ }
+ int l_out_num = 0;
+ if (!dap_chain_datum_tx_out_cond_get(l_tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, &l_out_num)) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s is invalid", l_tx_hash_str_tmp);
+ return -22;
+ }
+ dap_hash_fast_t l_spender_hash = {};
+ if (dap_ledger_tx_hash_is_used_out_item(l_net->pub.ledger, &l_tx_hash, l_out_num, &l_spender_hash)) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s is spent", l_tx_hash_str_tmp);
+ return -23;
+ }
+
+ const char* l_sign_str = "";
+ dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config), NULL);
+ if (!l_wallet) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet %s not found", l_wallet_str);
+ return -18;
+ } else {
+ l_sign_str = dap_chain_wallet_check_sign(l_wallet);
+ }
+ dap_enc_key_t *l_enc_key = dap_chain_wallet_get_key(l_wallet, 0);
+ dap_chain_datum_tx_t *l_tx_new = s_stake_tx_update(l_net, &l_tx_hash, l_value, l_fee, l_enc_key);
+ dap_chain_wallet_close(l_wallet);
+ dap_enc_key_delete(l_enc_key);
+ char *l_out_hash_str = NULL;
+ if (l_tx_new && (l_out_hash_str = s_stake_tx_put(l_tx_new, l_net, a_hash_out_type))) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%sDelegated m-tokens value will change. Updating tx hash is %s.", l_sign_str, l_out_hash_str);
+ DAP_DELETE(l_out_hash_str);
+ DAP_DELETE(l_tx_new);
+ } else {
+ l_tx_hash_str = dap_chain_hash_fast_to_str_static(&l_tx_hash);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose updating transaction %s, examine log files for details", l_tx_hash_str);
+ DAP_DEL_Z(l_tx_new);
+ return -21;
+ }
+ return 0;
+}
+
+
static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index, void **a_str_reply, const char *a_hash_out_type)
{
const char *l_net_str = NULL,
*l_wallet_str = NULL,
*l_fee_str = NULL,
*l_tx_hash_str = NULL,
- *l_cert_str = NULL,
*l_poa_cert_str = NULL,
*l_signing_pkey_hash_str = NULL,
*l_signing_pkey_type_str = NULL;
@@ -1962,7 +2282,7 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
} else {
dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-fee", &l_fee_str);
if (!l_fee_str) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'delegate' requires parameter -fee");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' requires parameter -fee");
return -5;
}
l_fee = dap_chain_balance_scan(l_fee_str);
@@ -1973,22 +2293,19 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
}
dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-tx", &l_tx_hash_str);
if (!l_tx_hash_str) {
- dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str);
- if (!l_cert_str) {
- dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-signing_pkey_hash", &l_signing_pkey_hash_str);
- if (!l_signing_pkey_hash_str) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' requires parameter -tx or -cert or -signing_pkey_hash");
- return -13;
- }
- dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-signing_pkey_type", &l_signing_pkey_type_str);
- if (!l_signing_pkey_type_str) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' requires parameter -signing_pkey_type");
- return -14;
- }
- if (dap_sign_type_from_str(l_signing_pkey_type_str).type == SIG_TYPE_NULL) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid signing_pkey_type %s", l_signing_pkey_type_str);
- return -15;
- }
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-signing_pkey_hash", &l_signing_pkey_hash_str);
+ if (!l_signing_pkey_hash_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' requires parameter -tx or -signing_pkey_hash");
+ return -13;
+ }
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-signing_pkey_type", &l_signing_pkey_type_str);
+ if (!l_signing_pkey_type_str) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' requires parameter -signing_pkey_type");
+ return -14;
+ }
+ if (dap_sign_type_from_str(l_signing_pkey_type_str).type == SIG_TYPE_NULL) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid signing_pkey_type %s", l_signing_pkey_type_str);
+ return -15;
}
}
@@ -1996,29 +2313,13 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
if (l_tx_hash_str) {
dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash);
} else {
- dap_chain_addr_t l_signing_addr;
- if (l_cert_str) {
- dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
- if (!l_cert) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate not found");
- return -18;
- }
- if (!l_cert->enc_key->priv_key_data || l_cert->enc_key->priv_key_data_size == 0) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "It is not possible to invalidate a stake using a public key.");
- return -31;
- }
- if (dap_chain_addr_fill_from_key(&l_signing_addr, l_cert->enc_key, l_net->pub.id)) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate is wrong");
- return -22;
- }
- } else {
- dap_hash_fast_t l_pkey_hash = {};
- if (dap_chain_hash_fast_from_str(l_signing_pkey_hash_str, &l_pkey_hash)) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid pkey hash format");
- return -23;
- }
- dap_chain_addr_fill(&l_signing_addr, dap_sign_type_from_str(l_signing_pkey_type_str), &l_pkey_hash, l_net->pub.id);
+ dap_hash_fast_t l_pkey_hash = {};
+ if (dap_chain_hash_fast_from_str(l_signing_pkey_hash_str, &l_pkey_hash)) {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid pkey hash format");
+ return -23;
}
+ dap_chain_addr_t l_signing_addr;
+ dap_chain_addr_fill(&l_signing_addr, dap_sign_type_from_str(l_signing_pkey_type_str), &l_pkey_hash, l_net->pub.id);
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(l_net->pub.id);
if (!l_srv_stake) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified net have no stake service activated");
@@ -2048,14 +2349,10 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
}
dap_hash_fast_t l_spender_hash = {};
if (dap_ledger_tx_hash_is_used_out_item(l_net->pub.ledger, &l_tx_hash, l_out_num, &l_spender_hash)) {
- l_tx_hash = l_spender_hash;
- l_tx_hash_str_tmp = dap_hash_fast_to_str_static(&l_spender_hash);
- if (!dap_ledger_tx_find_by_hash(l_net->pub.ledger, &l_tx_hash)) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Previous transaction %s is not found", l_tx_hash_str_tmp);
- return -21;
- }
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s is spent", l_tx_hash_str_tmp);
+ return -23;
}
- if (l_tx_hash_str || l_cert_str) {
+ if (l_tx_hash_str) {
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(l_net->pub.id);
if (!l_srv_stake) {
dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified net have no stake service activated");
@@ -2087,13 +2384,13 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
dap_enc_key_delete(l_enc_key);
char *l_out_hash_str = NULL;
if (l_tx && (l_out_hash_str = s_stake_tx_put(l_tx, l_net, a_hash_out_type))) {
- dap_cli_server_cmd_set_reply_text(a_str_reply, "%sAll m-tokens successfully returned to "
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%sAll m-tokens will be returned to "
"owner. Returning tx hash %s.", l_sign_str, l_out_hash_str);
DAP_DELETE(l_out_hash_str);
DAP_DELETE(l_tx);
} else {
l_tx_hash_str = dap_chain_hash_fast_to_str_static(&l_tx_hash);
- dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't invalidate transaction %s, examine log files for details", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose invalidation transaction %s, examine log files for details", l_tx_hash_str);
DAP_DEL_Z(l_tx);
return -21;
}
@@ -2131,7 +2428,8 @@ static void s_srv_stake_print(dap_chain_net_srv_stake_item_t *a_stake, uint256_t
char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE], l_pkey_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
dap_chain_hash_fast_to_str(&a_stake->tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
dap_chain_hash_fast_to_str(&a_stake->signing_addr.data.hash_fast, l_pkey_hash_str, sizeof(l_pkey_hash_str));
- char *l_balance = dap_chain_balance_to_coins(a_stake->value);
+ char *l_balance = dap_chain_balance_to_coins(a_stake->locked_value);
+ char *l_effective_weight = dap_chain_balance_to_coins(a_stake->value);
uint256_t l_rel_weight, l_tmp;
MULT_256_256(a_stake->value, GET_256_FROM_64(100), &l_tmp);
DIV_256_COIN(l_tmp, a_total_weight, &l_rel_weight);
@@ -2146,16 +2444,18 @@ static void s_srv_stake_print(dap_chain_net_srv_stake_item_t *a_stake, uint256_t
char *l_sov_tax_str = dap_chain_balance_to_coins(l_sov_tax_percent);
dap_string_append_printf(a_string, "Pkey hash: %s\n"
"\tStake value: %s\n"
+ "\tEffective value: %s\n"
"\tRelated weight: %s%%\n"
"\tTx hash: %s\n"
"\tNode addr: "NODE_ADDR_FP_STR"\n"
"\tSovereign addr: %s\n"
"\tSovereign tax: %s%%\n"
"%s\n",
- l_pkey_hash_str, l_balance, l_rel_weight_str,
+ l_pkey_hash_str, l_balance, l_effective_weight, l_rel_weight_str,
l_tx_hash_str, NODE_ADDR_FP_ARGS_S(a_stake->node_addr),
l_sov_addr_str, l_sov_tax_str, l_active_str);
DAP_DELETE(l_balance);
+ DAP_DELETE(l_effective_weight);
DAP_DELETE(l_rel_weight_str);
DAP_DELETE(l_sov_tax_str);
}
@@ -2298,7 +2598,7 @@ int dap_chain_net_srv_stake_check_validator(dap_chain_net_t * a_net, dap_hash_fa
return l_overall_correct;
}
-uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id)
+uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id, uint256_t *a_locked_weight)
{
dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(a_net_id);
dap_return_val_if_fail(l_srv_stake, uint256_0);
@@ -2307,6 +2607,8 @@ uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id)
if (it->signing_addr.net_id.uint64 != a_net_id.uint64)
continue;
SUM_256_256(l_total_weight, it->value, &l_total_weight);
+ if (a_locked_weight)
+ SUM_256_256(*a_locked_weight, it->locked_value, a_locked_weight);
}
return l_total_weight;
}
@@ -2314,7 +2616,7 @@ uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id)
static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
{
enum {
- CMD_NONE, CMD_ORDER, CMD_DELEGATE, CMD_APPROVE, CMD_LIST, CMD_INVALIDATE, CMD_MIN_VALUE, CMD_CHECK, CMD_MAX_WEIGHT
+ CMD_NONE, CMD_ORDER, CMD_DELEGATE, CMD_UPDATE, CMD_APPROVE, CMD_LIST, CMD_INVALIDATE, CMD_MIN_VALUE, CMD_CHECK, CMD_MAX_WEIGHT
};
int l_arg_index = 1;
@@ -2334,6 +2636,10 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, dap_min(a_argc, l_arg_index + 1), "delegate", NULL)) {
l_cmd_num = CMD_DELEGATE;
}
+ // Create tx to change staker's funds for delegated key (if any)
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, dap_min(a_argc, l_arg_index + 1), "update", NULL)) {
+ l_cmd_num = CMD_UPDATE;
+ }
// Create tx to approve staker's funds freeze
else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, dap_min(a_argc, l_arg_index + 1), "approve", NULL)) {
l_cmd_num = CMD_APPROVE;
@@ -2365,6 +2671,9 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
case CMD_DELEGATE:
return s_cli_srv_stake_delegate(a_argc, a_argv, l_arg_index + 1, a_str_reply, l_hash_out_type);
+ case CMD_UPDATE:
+ return s_cli_srv_stake_update(a_argc, a_argv, l_arg_index + 1, a_str_reply, l_hash_out_type);
+
case CMD_INVALIDATE:
return s_cli_srv_stake_invalidate(a_argc, a_argv, l_arg_index + 1, a_str_reply, l_hash_out_type);
@@ -2555,7 +2864,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
dap_string_t *l_reply_str = dap_string_new("");
size_t l_inactive_count = 0, l_total_count = 0;
- uint256_t l_total_weight = dap_chain_net_srv_stake_get_total_weight(l_net->pub.id);
+ uint256_t l_total_locked_weight = {}, l_total_weight = dap_chain_net_srv_stake_get_total_weight(l_net->pub.id, &l_total_locked_weight);
if (l_stake)
s_srv_stake_print(l_stake, l_total_weight, l_reply_str);
else
@@ -2572,9 +2881,10 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
dap_string_append_printf(l_reply_str, "Total keys count: %zu\n", l_total_count);
if (dap_chain_esbocs_started(l_net->pub.id))
dap_string_append_printf(l_reply_str, "Inactive keys count: %zu\n", l_inactive_count);
- const char *l_total_weight_coins, *l_total_weight_str =
- dap_uint256_to_char(l_total_weight, &l_total_weight_coins);
+ const char *l_total_weight_coins, *l_total_weight_str = dap_uint256_to_char(l_total_locked_weight, &l_total_weight_coins);
dap_string_append_printf(l_reply_str, "Total weight: %s (%s)\n", l_total_weight_coins, l_total_weight_str);
+ l_total_weight_str = dap_uint256_to_char(l_total_weight, &l_total_weight_coins);
+ dap_string_append_printf(l_reply_str, "Total effective weight: %s (%s)\n", l_total_weight_coins, l_total_weight_str);
}
const char *l_delegate_min_str; dap_uint256_to_char(dap_chain_net_srv_stake_get_allowed_min_value(l_net->pub.id),
diff --git a/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h b/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h
index 19ca297c30461b77eaabcba70e1fca5096f64dfe..00449f6e4980fd11f0fd7f25267b6a68e5975594 100644
--- a/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h
+++ b/modules/service/stake/include/dap_chain_net_srv_stake_pos_delegate.h
@@ -72,6 +72,7 @@ int dap_chain_net_srv_stake_net_add(dap_chain_net_id_t a_net_id);
void dap_chain_net_srv_stake_key_delegate(dap_chain_net_t *a_net, dap_chain_addr_t *a_signing_addr, dap_hash_fast_t *a_stake_tx_hash,
uint256_t a_value, dap_chain_node_addr_t *a_node_addr);
void dap_chain_net_srv_stake_key_invalidate(dap_chain_addr_t *a_signing_addr);
+void dap_chain_net_srv_stake_key_update(dap_chain_addr_t *a_signing_addr, uint256_t a_new_value, dap_hash_fast_t *a_new_tx_hash);
void dap_chain_net_srv_stake_set_allowed_min_value(dap_chain_net_id_t a_net_id, uint256_t a_value);
uint256_t dap_chain_net_srv_stake_get_allowed_min_value(dap_chain_net_id_t a_net_id);
void dap_chain_net_srv_stake_set_percent_max(dap_chain_net_id_t a_net_id, uint256_t a_value);
@@ -98,5 +99,5 @@ dap_chain_datum_decree_t *dap_chain_net_srv_stake_decree_approve(dap_chain_net_t
int dap_chain_net_srv_stake_mark_validator_active(dap_chain_addr_t *a_signing_addr, bool a_on_off);
dap_chain_net_srv_stake_item_t *dap_chain_net_srv_stake_check_pkey_hash(dap_chain_net_id_t a_net_id, dap_hash_fast_t *a_pkey_hash);
-uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id);
+uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id, uint256_t *a_locked_weight);
size_t dap_chain_net_srv_stake_get_total_keys(dap_chain_net_id_t a_net_id, size_t *a_in_active_count);