From 26f58568801b083a78b334d5bd8ee1681d733da4 Mon Sep 17 00:00:00 2001
From: Aleksey Feoktistov <aleksey@synestproject.com>
Date: Wed, 1 Dec 2021 21:52:55 +0500
Subject: [PATCH] [*] added structures for new type items
---
modules/chain/dap_chain_ledger.c | 218 +++++++++++++-----
modules/common/dap_chain_datum_token.c | 70 ++++--
modules/common/dap_chain_datum_tx.c | 6 +-
modules/common/dap_chain_datum_tx_items.c | 63 +++--
.../common/include/dap_chain_datum_token.h | 12 +-
.../common/include/dap_chain_datum_tx_items.h | 12 +-
.../common/include/dap_chain_datum_tx_out.h | 14 +-
.../include/dap_chain_datum_tx_out_cond.h | 72 +++++-
.../include/dap_chain_datum_tx_out_ext.h | 15 +-
modules/consensus/none/dap_chain_cs_none.c | 8 +-
modules/net/dap_chain_net.c | 101 +++++---
modules/net/dap_chain_node_cli_cmd.c | 8 +-
modules/net/dap_chain_node_cli_cmd_tx.c | 150 ++++++------
modules/type/blocks/dap_chain_cs_blocks.c | 8 +-
modules/type/dag/dap_chain_cs_dag.c | 8 +-
15 files changed, 518 insertions(+), 247 deletions(-)
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 69262d3273..e877198171 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -144,6 +144,10 @@ typedef struct dap_chain_ledger_tx_bound {
dap_chain_tx_out_t *tx_prev_out;
dap_chain_tx_out_ext_t *tx_prev_out_ext;
dap_chain_tx_out_cond_t *tx_prev_out_cond;
+ // 256
+ dap_chain_256_tx_out_t *tx_prev_out_256;
+ dap_chain_256_tx_out_ext_t *tx_prev_out_ext_256;
+ dap_chain_256_tx_out_cond_t *tx_prev_out_cond_256;
} out;
dap_chain_ledger_tx_item_t *item_out;
} dap_chain_ledger_tx_bound_t;
@@ -1153,7 +1157,7 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
: &l_ledger_priv->treshold_emissions_rwlock);
if(l_token_emission_item ) {
if(s_debug_more)
- if ( l_token_emission_item->datum_token_emission->hdr.type_value_256 )
+ if ( dap_chain_datum_token_emission_is_type_256(l_token_emission_item->datum_token_emission->hdr.type) )
log_it(L_ERROR, "Can't add token emission datum of %s %s ( %s ): already present in cache",
dap_chain_u256tostr(l_token_emission_item->datum_token_emission->hdr.value_256), c_token_ticker, l_hash_str);
else
@@ -1169,6 +1173,7 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
size_t l_emission_size = a_token_emission_size;
dap_chain_datum_token_emission_t *l_emission = dap_chain_datum_emission_read(a_token_emission, &l_emission_size);
switch (l_emission->hdr.type){
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH:
case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:{
dap_chain_ledger_token_item_t *l_token_item=NULL;
pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
@@ -1207,7 +1212,7 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
if (l_aproves < l_aproves_valid ){
if(s_debug_more)
- if ( l_emission->hdr.type_value_256 ) // 256
+ if ( dap_chain_datum_token_emission_is_type_256(l_emission->hdr.type) ) // 256
log_it(L_WARNING, "Emission of %s datoshi of %s:%s is wrong: only %u valid aproves when %u need",
dap_chain_u256tostr(l_emission->hdr.value_256), a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
else
@@ -1291,7 +1296,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
DAP_DELETE(l_gdb_group);
char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_emission_item->datum_token_emission->hdr.address) );
if(s_debug_more)
- if ( l_token_emission_item->datum_token_emission->hdr.type_value_256 ) // 256
+ if ( dap_chain_datum_token_emission_is_type_256(l_token_emission_item->datum_token_emission->hdr.type) ) // 256
log_it(L_NOTICE, "Added token emission datum to %s: type=%s value=%.1Lf token=%s to_addr=%s ",
l_token_item?"emissions cache":"emissions treshold",
c_dap_chain_datum_token_emission_type_str[ l_token_emission_item->datum_token_emission->hdr.type ] ,
@@ -1315,7 +1320,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
} else {
if (l_token_item) {
if(s_debug_more)
- if ( ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.type_value_256 ) // 256
+ if ( dap_chain_datum_token_emission_is_type_256(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.type) ) // 256
log_it(L_ERROR, "Duplicate token emission datum of %s %s ( %s )",
dap_chain_u256tostr(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value_256), c_token_ticker, l_hash_str);
else
@@ -1761,14 +1766,36 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
if (l_cond_type == TX_ITEM_TYPE_IN) {
dap_chain_tx_item_type_t l_type = *(uint8_t *)l_tx_prev_out;
- if ( l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT ) {
+ // if ( l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT ) {
+ // bound_item->out.tx_prev_out = l_tx_prev_out;
+ // memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out->addr,sizeof (bound_item->out.tx_prev_out->addr));
+ // } else {
+ // bound_item->out.tx_prev_out_ext = l_tx_prev_out;
+ // memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_ext->addr,sizeof (bound_item->out.tx_prev_out_ext->addr));
+ // }
+
+ if ( l_type == TX_ITEM_TYPE_OUT ) {
+ l_is_type_256 = false;
bound_item->out.tx_prev_out = l_tx_prev_out;
- memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out->addr,sizeof (bound_item->out.tx_prev_out->addr));
- } else {
+ memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out->addr,sizeof (bound_item->out.tx_prev_out->addr));
+ } else if ( l_type == TX_ITEM_TYPE_256_OUT ) { // 256
+ l_is_type_256 = true;
+ bound_item->out.tx_prev_out_256 = l_tx_prev_out;
+ memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_256->addr,sizeof (bound_item->out.tx_prev_out_256->addr));
+ } else if (l_type == TX_ITEM_TYPE_OUT_EXT ) {
+ l_is_type_256 = false;
bound_item->out.tx_prev_out_ext = l_tx_prev_out;
memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_ext->addr,sizeof (bound_item->out.tx_prev_out_ext->addr));
+ } else if ( l_type == TX_ITEM_TYPE_256_OUT_EXT ) { // 256
+ l_is_type_256 = true;
+ bound_item->out.tx_prev_out_ext_256 = l_tx_prev_out;
+ memcpy(&l_tx_in_from, &bound_item->out.tx_prev_out_ext_256->addr,sizeof (bound_item->out.tx_prev_out_ext_256->addr));
+ } else {
+ l_err_num = -8;
+ break;
}
+
// calculate hash of public key in current transaction
dap_chain_hash_fast_t l_hash_pkey;
{
@@ -1784,9 +1811,24 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
dap_hash_fast(l_pkey_ser, l_pkey_ser_size, &l_hash_pkey);
// hash of public key in 'out' item of previous transaction
- uint8_t *l_prev_out_addr_key = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ?
- bound_item->out.tx_prev_out->addr.data.key :
- bound_item->out.tx_prev_out_ext->addr.data.key;
+ // uint8_t *l_prev_out_addr_key = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ?
+ // bound_item->out.tx_prev_out->addr.data.key :
+ // bound_item->out.tx_prev_out_ext->addr.data.key;
+
+ uint8_t *l_prev_out_addr_key = NULL;
+ switch (l_type) {
+ case TX_ITEM_TYPE_256_OUT:
+ l_prev_out_addr_key = bound_item->out.tx_prev_out_256->addr.data.key; break;
+ case TX_ITEM_TYPE_OUT:
+ l_prev_out_addr_key = bound_item->out.tx_prev_out->addr.data.key; break;
+ case TX_ITEM_TYPE_256_OUT_EXT:
+ l_prev_out_addr_key = bound_item->out.tx_prev_out_ext_256->addr.data.key; break;
+ case TX_ITEM_TYPE_OUT_EXT:
+ l_prev_out_addr_key = bound_item->out.tx_prev_out_ext->addr.data.key; break;
+ default:
+ log_it(L_DEBUG, "Unknown item type %d", l_type);
+ break;
+ }
// 4. compare public key hashes in the signature of the current transaction and in the 'out' item of the previous transaction
if(memcmp(&l_hash_pkey, l_prev_out_addr_key, sizeof(dap_chain_hash_fast_t))) {
@@ -1797,11 +1839,11 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
switch (l_type) {
case TX_ITEM_TYPE_256_OUT: // 256
- l_value_256 = bound_item->out.tx_prev_out->header.value_256; break;
+ l_value_256 = bound_item->out.tx_prev_out_256->header.value; break;
case TX_ITEM_TYPE_OUT:
l_value = bound_item->out.tx_prev_out->header.value; break;
case TX_ITEM_TYPE_256_OUT_EXT: // 256
- l_value_256 = bound_item->out.tx_prev_out_ext->header.value_256;
+ l_value_256 = bound_item->out.tx_prev_out_ext_256->header.value;
l_token = bound_item->out.tx_prev_out_ext->token;
break;
case TX_ITEM_TYPE_OUT_EXT:
@@ -1834,9 +1876,20 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
size_t l_pkey_ser_size = 0;
const uint8_t *l_pkey_ser = dap_sign_get_pkey(l_sign, &l_pkey_ser_size);
- dap_chain_tx_out_cond_t *l_tx_prev_out_cond = (dap_chain_tx_out_cond_t *)l_tx_prev_out;
- l_is_type_256 = l_type == TX_ITEM_TYPE_256_OUT_COND ? true : false;
+ dap_chain_tx_out_cond_t *l_tx_prev_out_cond = NULL;
+ dap_chain_256_tx_out_cond_t *l_tx_prev_out_cond_256 = NULL; // 256
+
+ if ( l_type == TX_ITEM_TYPE_256_OUT_COND ) { // 256
+ l_is_type_256 = true;
+ l_tx_prev_out_cond_256 = (dap_chain_256_tx_out_cond_t *)l_tx_prev_out;
+ } else {
+ l_is_type_256 = false;
+ l_tx_prev_out_cond = (dap_chain_tx_out_cond_t *)l_tx_prev_out;
+ }
+
+ // dap_chain_tx_out_cond_t *l_tx_prev_out_cond = (dap_chain_tx_out_cond_t *)l_tx_prev_out;
+ // l_is_type_256 = l_type == TX_ITEM_TYPE_256_OUT_COND ? true : false;
bool l_owner = false;
if (l_pkey_ser_size == l_prev_pkey_ser_size &&
@@ -1845,7 +1898,17 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
// 5b. Call verificator for conditional output
dap_chain_ledger_verificator_t *l_verificator;
- int l_tmp = (int)l_tx_prev_out_cond->header.subtype;
+ // int l_tmp = (int)l_tx_prev_out_cond->header.subtype;
+ // int l_tmp;
+ // if ( l_type == TX_ITEM_TYPE_256_OUT_COND ) { // 256
+ // l_tmp = (int)l_tx_prev_out_cond_256->header.subtype;
+ // } else {
+ // l_tmp = (int)l_tx_prev_out_cond->header.subtype;
+ // }
+
+ int l_tmp = ( l_type == TX_ITEM_TYPE_256_OUT_COND ) ?
+ (int)l_tx_prev_out_cond_256->header.subtype : (int)l_tx_prev_out_cond->header.subtype;
+
pthread_rwlock_rdlock(&s_verificators_rwlock);
HASH_FIND_INT(s_verificators, &l_tmp, l_verificator);
pthread_rwlock_unlock(&s_verificators_rwlock);
@@ -1860,10 +1923,12 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
break;
}
- bound_item->out.tx_prev_out_cond = l_tx_prev_out_cond;
+ // bound_item->out.tx_prev_out_cond = l_tx_prev_out_cond;
if ( l_type == TX_ITEM_TYPE_256_OUT_COND ) { // 256
- l_value_256 = l_tx_prev_out_cond->header.value_256;
+ bound_item->out.tx_prev_out_cond_256 = l_tx_prev_out_cond;
+ l_value_256 = l_tx_prev_out_cond_256->header.value;
} else {
+ bound_item->out.tx_prev_out_cond = l_tx_prev_out_cond;
l_value = l_tx_prev_out_cond->header.value;
}
l_token = NULL;
@@ -1915,6 +1980,21 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
}
}
+ // HASH_FIND_STR(l_values_from_prev_tx, l_token, l_value_cur);
+ // if (!l_value_cur) {
+ // l_value_cur = DAP_NEW_Z(dap_chain_ledger_tokenizer_t);
+ // strcpy(l_value_cur->token_ticker, l_token);
+ // HASH_ADD_STR(l_values_from_prev_tx, token_ticker, l_value_cur);
+
+ // if ( l_is_type_256 ) { // 256
+ // l_value_cur->type_256 = true;
+ // SUM_256_256(l_value_cur->sum_256, l_value_256, &l_value_cur->sum_256);
+ // }else {
+ // l_value_cur->type_256 = false;
+ // l_value_cur->sum += l_value;
+ // }
+ // }
+
if ( l_is_type_256 ) { // 256
HASH_FIND_STR(l_values_from_prev_tx_256, l_token, l_value_cur_256);
if (!l_value_cur_256) {
@@ -1997,13 +2077,13 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
} else if (l_type == TX_ITEM_TYPE_256_OUT) { // 256
l_is_type_256 = true;
- dap_chain_tx_out_t *l_tx_out = (dap_chain_tx_out_t *)l_list_tmp->data;
+ dap_chain_256_tx_out_t *l_tx_out = (dap_chain_256_tx_out_t *)l_list_tmp->data;
if (l_multichannel) { // token ticker is mandatory for multichannel transactions
l_err_num = -16;
break;
}
if (emission_flag) {
- l_value_256 = l_tx_out->header.value_256;
+ l_value_256 = l_tx_out->header.value;
}
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
l_list_tx_out = dap_list_append(l_list_tx_out, l_tx_out);
@@ -2024,13 +2104,13 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
} else if (l_type == TX_ITEM_TYPE_256_OUT_EXT) { // 256
l_is_type_256 = true;
- dap_chain_tx_out_ext_t *l_tx_out = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
+ dap_chain_256_tx_out_ext_t *l_tx_out = (dap_chain_256_tx_out_ext_t *)l_list_tmp->data;
if (!l_multichannel) { // token ticker is depricated for single-channel transactions
l_err_num = -16;
break;
}
if (emission_flag) {
- l_value_256 = l_tx_out->header.value_256;
+ l_value_256 = l_tx_out->header.value;
l_token = l_tx_out->token;
}
memcpy(&l_tx_out_to , &l_tx_out->addr, sizeof (l_tx_out_to));
@@ -2051,9 +2131,9 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
} else if (l_type == TX_ITEM_TYPE_256_OUT_COND) { // 256
l_is_type_256 = true;
- dap_chain_tx_out_cond_t *l_tx_out = (dap_chain_tx_out_cond_t *)l_list_tmp->data;
+ dap_chain_256_tx_out_cond_t *l_tx_out = (dap_chain_256_tx_out_cond_t *)l_list_tmp->data;
if (emission_flag) {
- l_value_256 = l_tx_out->header.value_256;
+ l_value_256 = l_tx_out->header.value;
}
if (l_multichannel) { // out_cond have no field .token
log_it(L_WARNING, "No conditional output support for multichannel transaction");
@@ -2371,10 +2451,18 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
dap_chain_ledger_tx_item_t *l_prev_item_out = bound_item->item_out;
- l_ticker_trl = *l_prev_item_out->cache_data.token_tiker
- ? dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_tiker)
- : dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext->token);
+ // l_ticker_trl = *l_prev_item_out->cache_data.token_tiker
+ // ? dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_tiker)
+ // : dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext->token);
+ if ( *l_prev_item_out->cache_data.token_tiker )
+ l_ticker_trl = dap_stpcpy(l_token_ticker, l_prev_item_out->cache_data.token_tiker);
+ else if ( l_out_type == TX_ITEM_TYPE_256_OUT || l_out_type == TX_ITEM_TYPE_256_OUT_EXT ) // 256
+ l_ticker_trl = dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext_256->token);
+ else
+ l_ticker_trl = dap_stpcpy(l_token_ticker, bound_item->out.tx_prev_out_ext->token);
+
+
if (!l_multichannel && l_ticker_old_trl && strcmp(l_token_ticker, l_token_ticker_old)) {
l_multichannel = true;
}
@@ -2385,14 +2473,22 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
dap_chain_tx_in_t *l_tx_in = bound_item->in.tx_cur_in;
dap_ledger_wallet_balance_t *wallet_balance = NULL;
//void *l_item_out = *(void **)&bound_item->out;
- //dap_chain_tx_item_type_t l_out_type = *(uint8_t *)l_item_out;
-
- //dap_chain_addr_t *l_addr = NULL;
uint256_t l_value = uint256_0;
- dap_chain_addr_t *l_addr = (l_out_type == TX_ITEM_TYPE_OUT || l_out_type == TX_ITEM_TYPE_256_OUT) ?
- &bound_item->out.tx_prev_out->addr :
- &bound_item->out.tx_prev_out_ext->addr;
+ dap_chain_addr_t *l_addr = NULL;
+ switch (l_out_type) {
+ case TX_ITEM_TYPE_256_OUT: l_addr = &bound_item->out.tx_prev_out_256->addr; break;
+ case TX_ITEM_TYPE_OUT: l_addr = &bound_item->out.tx_prev_out->addr; break;
+ case TX_ITEM_TYPE_256_OUT_EXT: l_addr = &bound_item->out.tx_prev_out_ext_256->addr; break;
+ case TX_ITEM_TYPE_OUT_EXT: l_addr = &bound_item->out.tx_prev_out_ext->addr; break;
+ default:
+ log_it(L_DEBUG, "Unknown item type %d", l_type);
+ break;
+ }
+
+ // dap_chain_addr_t *l_addr = (l_out_type == TX_ITEM_TYPE_OUT || l_out_type == TX_ITEM_TYPE_256_OUT) ?
+ // &bound_item->out.tx_prev_out->addr :
+ // &bound_item->out.tx_prev_out_ext->addr;
char *l_addr_str = dap_chain_addr_to_str(l_addr);
char *l_wallet_balance_key = dap_strjoin(" ", l_addr_str, l_token_ticker, (char*)NULL);
@@ -2401,9 +2497,9 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
pthread_rwlock_unlock(&PVT(a_ledger)->balance_accounts_rwlock);
if (wallet_balance) {
switch (l_out_type) {
- case TX_ITEM_TYPE_256_OUT: l_value = bound_item->out.tx_prev_out->header.value_256; break;
+ case TX_ITEM_TYPE_256_OUT: l_value = bound_item->out.tx_prev_out_256->header.value; break;
case TX_ITEM_TYPE_OUT: l_value = GET_256_FROM_64(bound_item->out.tx_prev_out->header.value); break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_value = bound_item->out.tx_prev_out_ext->header.value_256; break;
+ case TX_ITEM_TYPE_256_OUT_EXT: l_value = bound_item->out.tx_prev_out_ext_256->header.value; break;
case TX_ITEM_TYPE_OUT_EXT: l_value = GET_256_FROM_64(bound_item->out.tx_prev_out_ext->header.value); break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
@@ -2521,22 +2617,34 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
}
dap_chain_tx_out_t *l_out_item = NULL;
+ dap_chain_256_tx_out_t *l_out_item_256 = NULL;
dap_chain_tx_out_ext_t *l_out_item_ext = NULL;
+ dap_chain_256_tx_out_ext_t *l_out_item_ext_256 = NULL;
+
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT: l_out_item = (dap_chain_tx_out_t *)l_tx_out->data; break;
+ case TX_ITEM_TYPE_256_OUT: l_out_item_256 = (dap_chain_256_tx_out_t *)l_tx_out->data; break;
case TX_ITEM_TYPE_OUT: l_out_item = (dap_chain_tx_out_t *)l_tx_out->data; break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_out_item_ext = (dap_chain_tx_out_ext_t *)l_tx_out->data; break;
+ case TX_ITEM_TYPE_256_OUT_EXT: l_out_item_ext_256 = (dap_chain_256_tx_out_ext_t *)l_tx_out->data; break;
case TX_ITEM_TYPE_OUT_EXT: l_out_item_ext = (dap_chain_tx_out_ext_t *)l_tx_out->data; break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
break;
}
- if ((l_out_item || l_out_item_ext) && l_ticker_trl) {
- dap_chain_addr_t *l_addr = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ?
- &l_out_item->addr :
- &l_out_item_ext->addr;
-
+ if ((l_out_item||l_out_item_ext||l_out_item_256||l_out_item_ext_256) && l_ticker_trl) {
+ // dap_chain_addr_t *l_addr = (l_type == TX_ITEM_TYPE_OUT || l_type == TX_ITEM_TYPE_256_OUT) ?
+ // &l_out_item->addr :
+ // &l_out_item_ext->addr;
+ dap_chain_addr_t *l_addr;
+ switch (l_type) {
+ case TX_ITEM_TYPE_256_OUT: l_addr = &l_out_item_256->addr; break;
+ case TX_ITEM_TYPE_OUT: l_addr = &l_out_item->addr; break;
+ case TX_ITEM_TYPE_256_OUT_EXT: l_addr = &l_out_item_ext_256->addr; break;
+ case TX_ITEM_TYPE_OUT_EXT: l_addr = &l_out_item_ext->addr; break;
+ default:
+ log_it(L_DEBUG, "Unknown item type %d", l_type);
+ break;
+ }
char *l_addr_str = dap_chain_addr_to_str(l_addr);
//log_it (L_DEBUG, "Check unspent %.03Lf %s for addr %s",
@@ -2551,9 +2659,9 @@ int dap_chain_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx,
uint64_t l_value = 0;
uint256_t l_value_256 = uint256_0;
switch (l_type) {
- case TX_ITEM_TYPE_256_OUT: l_value_256 = l_out_item->header.value_256; break; // _256
+ case TX_ITEM_TYPE_256_OUT: l_value_256 = l_out_item_256->header.value; break; // _256
case TX_ITEM_TYPE_OUT: l_value_256 = GET_256_FROM_64(l_out_item->header.value); break;
- case TX_ITEM_TYPE_256_OUT_EXT: l_value_256 = l_out_item_ext->header.value_256; break; // _256
+ case TX_ITEM_TYPE_256_OUT_EXT: l_value_256 = l_out_item_ext_256->header.value; break; // _256
case TX_ITEM_TYPE_OUT_EXT: l_value_256 = GET_256_FROM_64(l_out_item_ext->header.value); break;
default:
log_it(L_DEBUG, "Unknown item type %d", l_type);
@@ -2972,8 +3080,8 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
}
}
if (l_type == TX_ITEM_TYPE_256_OUT) { // 256
- //const dap_chain_256_tx_out_t *l_tx_out = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
- const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
+ const dap_chain_256_tx_out_t *l_tx_out = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
+ // const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
// Check for token name
if (!strcmp(a_token_ticker, l_iter_current->cache_data.token_tiker))
{ // if transaction has the out item with requested addr
@@ -2981,7 +3089,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
// if 'out' item not used & transaction is valid
if(!dap_chain_ledger_item_is_used_out(l_iter_current, l_out_idx_tmp) &&
dap_chain_datum_tx_verify_sign(l_cur_tx)) {
- SUM_256_256(balance, l_tx_out->header.value_256, &balance);
+ SUM_256_256(balance, l_tx_out->header.value, &balance);
}
}
}
@@ -3002,8 +3110,8 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
}
}
if (l_type == TX_ITEM_TYPE_256_OUT_EXT) { // 256
- // const dap_chain_256_tx_out_ext_t *l_tx_out = (const dap_chain_256_tx_out_ext_t*) l_list_tmp->data;
- const dap_chain_tx_out_ext_t *l_tx_out = (const dap_chain_tx_out_ext_t*) l_list_tmp->data;
+ const dap_chain_256_tx_out_ext_t *l_tx_out = (const dap_chain_256_tx_out_ext_t*) l_list_tmp->data;
+ // const dap_chain_tx_out_ext_t *l_tx_out = (const dap_chain_tx_out_ext_t*) l_list_tmp->data;
// Check for token name
if (!strcmp(a_token_ticker, l_tx_out->token))
{ // if transaction has the out item with requested addr
@@ -3011,7 +3119,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
// if 'out' item not used & transaction is valid
if(!dap_chain_ledger_item_is_used_out(l_iter_current, l_out_idx_tmp) &&
dap_chain_datum_tx_verify_sign(l_cur_tx)) {
- SUM_256_256(balance, l_tx_out->header.value_256, &balance);
+ SUM_256_256(balance, l_tx_out->header.value, &balance);
}
}
}
@@ -3301,11 +3409,11 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
l_value = GET_256_FROM_64(l_out->header.value);
} break;
case TX_ITEM_TYPE_256_OUT: {
- dap_chain_tx_out_t *l_out = (dap_chain_tx_out_t *)l_list_tmp->data;
- if ( IS_ZERO_256(l_out->header.value_256) || memcmp(a_addr_from, &l_out->addr, sizeof(dap_chain_addr_t))) {
+ dap_chain_256_tx_out_t *l_out = (dap_chain_256_tx_out_t *)l_list_tmp->data;
+ if ( IS_ZERO_256(l_out->header.value) || memcmp(a_addr_from, &l_out->addr, sizeof(dap_chain_addr_t))) {
continue;
}
- l_value = l_out->header.value_256;
+ l_value = l_out->header.value;
} break;
case TX_ITEM_TYPE_OUT_EXT: {
dap_chain_tx_out_ext_t *l_out_ext = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
@@ -3316,12 +3424,12 @@ dap_list_t *dap_chain_ledger_get_list_tx_outs_with_val(dap_ledger_t *a_ledger, c
l_value = GET_256_FROM_64(l_out_ext->header.value);
} break;
case TX_ITEM_TYPE_256_OUT_EXT: {
- dap_chain_tx_out_ext_t *l_out_ext = (dap_chain_tx_out_ext_t *)l_list_tmp->data;
- if ( IS_ZERO_256(l_out_ext->header.value_256) || memcmp(a_addr_from, &l_out_ext->addr, sizeof(dap_chain_addr_t)) ||
+ dap_chain_256_tx_out_ext_t *l_out_ext = (dap_chain_256_tx_out_ext_t *)l_list_tmp->data;
+ if ( IS_ZERO_256(l_out_ext->header.value) || memcmp(a_addr_from, &l_out_ext->addr, sizeof(dap_chain_addr_t)) ||
strcmp((char *)a_token_ticker, l_out_ext->token)) {
continue;
}
- l_value = l_out_ext->header.value_256;
+ l_value = l_out_ext->header.value;
} break;
}
// if (l_type == TX_ITEM_TYPE_OUT) {
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 140a22e8cd..8daa95e7f7 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -35,6 +35,12 @@ const char *c_dap_chain_datum_token_emission_type_str[]={
[DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO] = "ALGO",
[DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER] = "OWNER",
[DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT] = "SMART_CONTRACT",
+// 256 types
+ [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_UNDEFINED] = "UNDEFINED",
+ [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH] = "AUTH",
+ [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ALGO] = "ALGO",
+ [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ATOM_OWNER] = "OWNER",
+ [DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_SMART_CONTRACT] = "SMART_CONTRACT",
};
const char *c_dap_chain_datum_token_flag_str[] = {
@@ -212,26 +218,31 @@ size_t dap_chain_datum_emission_get_size(uint8_t *a_emission_serial)
l_ret = sizeof(l_emission->hdr);
}
switch (l_emission->hdr.type) {
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH: {
- uint16_t l_sign_count = *(uint16_t *)(a_emission_serial + l_ret);
- l_ret += sizeof(l_emission->data.type_auth);
- for (uint16_t i = 0; i < l_sign_count; i++) {
- dap_sign_t *l_sign = (dap_sign_t *)(a_emission_serial + l_ret);
- l_ret += dap_sign_get_size(l_sign);
- }
- } break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
- l_ret += sizeof(l_emission->data.type_algo);
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
- l_ret += sizeof(l_emission->data.type_atom_owner);
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT:
- l_ret += sizeof(l_emission->data.type_presale);
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
- default:
- break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH: {
+ uint16_t l_sign_count = *(uint16_t *)(a_emission_serial + l_ret);
+ l_ret += sizeof(l_emission->data.type_auth);
+ for (uint16_t i = 0; i < l_sign_count; i++) {
+ dap_sign_t *l_sign = (dap_sign_t *)(a_emission_serial + l_ret);
+ l_ret += dap_sign_get_size(l_sign);
+ }
+ } break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ALGO:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
+ l_ret += sizeof(l_emission->data.type_algo);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ATOM_OWNER: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
+ l_ret += sizeof(l_emission->data.type_atom_owner);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_SMART_CONTRACT: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT:
+ l_ret += sizeof(l_emission->data.type_presale);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_UNDEFINED: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
+ default:
+ break;
}
return l_ret;
}
@@ -253,7 +264,24 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emissi
l_emission_size - l_old_hdr_size);
l_emission_size += l_add_size;
(*a_emission_size) = l_emission_size;
- } else
+ } else {
l_emission = DAP_DUP_SIZE(a_emission_serial, (*a_emission_size));
+ }
return l_emission;
}
+
+// 256 TYPE
+bool dap_chain_datum_token_emission_is_type_256(uint8_t a_em_type) {
+ switch(a_em_type) {
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT:
+ return false;
+ default:
+ return true;
+ }
+}
+
+
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 7c91336dfc..7cb301e07e 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -182,7 +182,7 @@ int dap_chain_datum_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain
// 256
int dap_chain_datum_256_tx_add_out_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value)
{
- dap_chain_tx_out_t *l_tx_out = dap_chain_datum_tx_item_256_out_create(a_addr, a_value);
+ dap_chain_256_tx_out_t *l_tx_out = dap_chain_datum_tx_item_256_out_create(a_addr, a_value);
if(l_tx_out) {
dap_chain_datum_tx_add_item(a_tx, (const uint8_t *)l_tx_out);
DAP_DELETE(l_tx_out);
@@ -210,7 +210,7 @@ int dap_chain_datum_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_c
// 256
int dap_chain_datum_256_tx_add_out_ext_item(dap_chain_datum_tx_t **a_tx, const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
{
- dap_chain_tx_out_ext_t *l_tx_out = dap_chain_datum_tx_item_256_out_ext_create(a_addr, a_value, a_token);
+ dap_chain_256_tx_out_ext_t *l_tx_out = dap_chain_datum_tx_item_256_out_ext_create(a_addr, a_value, a_token);
if(l_tx_out) {
dap_chain_datum_tx_add_item(a_tx, (const uint8_t *)l_tx_out);
DAP_DELETE(l_tx_out);
@@ -240,7 +240,7 @@ int dap_chain_datum_tx_add_out_cond_item(dap_chain_datum_tx_t **a_tx, dap_enc_ke
int dap_chain_datum_256_tx_add_out_cond_item(dap_chain_datum_tx_t **a_tx, dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
uint256_t a_value, uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit, const void *a_cond, size_t a_cond_size)
{
- dap_chain_tx_out_cond_t *l_tx_out = dap_chain_datum_tx_item_256_out_cond_create_srv_pay(
+ dap_chain_256_tx_out_cond_t *l_tx_out = dap_chain_datum_tx_item_256_out_cond_create_srv_pay(
a_key, a_srv_uid,a_value, a_value_max_per_unit, a_unit, a_cond, a_cond_size );
if(l_tx_out) {
dap_chain_datum_tx_add_item(a_tx, (const uint8_t *) l_tx_out);
diff --git a/modules/common/dap_chain_datum_tx_items.c b/modules/common/dap_chain_datum_tx_items.c
index 5648eb92cf..59b64a3aee 100644
--- a/modules/common/dap_chain_datum_tx_items.c
+++ b/modules/common/dap_chain_datum_tx_items.c
@@ -58,6 +58,13 @@ static size_t dap_chain_tx_out_get_size(const dap_chain_tx_out_t *a_item)
return size;
}
+// 256
+static size_t dap_chain_256_tx_out_get_size(const dap_chain_256_tx_out_t *a_item)
+{
+ (void) a_item;
+ size_t size = sizeof(dap_chain_256_tx_out_t);
+ return size;
+}
static size_t dap_chain_tx_out_ext_get_size(const dap_chain_tx_out_ext_t *a_item)
{
@@ -66,12 +73,26 @@ static size_t dap_chain_tx_out_ext_get_size(const dap_chain_tx_out_ext_t *a_item
return size;
}
+// 256
+static size_t dap_chain_256_tx_out_ext_get_size(const dap_chain_256_tx_out_ext_t *a_item)
+{
+ (void) a_item;
+ size_t size = sizeof(dap_chain_256_tx_out_ext_t);
+ return size;
+}
static size_t dap_chain_tx_out_cond_get_size(const dap_chain_tx_out_cond_t *a_item)
{
return sizeof(dap_chain_tx_out_cond_t) + a_item->params_size;
}
+// 256
+static size_t dap_chain_256_tx_out_cond_get_size(const dap_chain_256_tx_out_cond_t *a_item)
+{
+ return sizeof(dap_chain_256_tx_out_cond_t) + a_item->params_size;
+}
+
+
static size_t dap_chain_tx_pkey_get_size(const dap_chain_tx_pkey_t *a_item)
{
size_t size = sizeof(dap_chain_tx_pkey_t) + a_item->header.sig_size;
@@ -120,13 +141,13 @@ size_t dap_chain_datum_item_tx_get_size(const uint8_t *a_item)
size = dap_chain_tx_out_get_size((const dap_chain_tx_out_t*) a_item);
break;
case TX_ITEM_TYPE_256_OUT: // 256
- size = dap_chain_tx_out_get_size((const dap_chain_tx_out_t*) a_item);
+ size = dap_chain_256_tx_out_get_size((const dap_chain_256_tx_out_t*) a_item);
break;
case TX_ITEM_TYPE_OUT_EXT:
size = dap_chain_tx_out_ext_get_size((const dap_chain_tx_out_ext_t*) a_item);
break;
case TX_ITEM_TYPE_256_OUT_EXT: // 256
- size = dap_chain_tx_out_ext_get_size((const dap_chain_tx_out_ext_t*) a_item);
+ size = dap_chain_256_tx_out_ext_get_size((const dap_chain_256_tx_out_ext_t*) a_item);
break;
case TX_ITEM_TYPE_RECEIPT: // Receipt
size = dap_chain_datum_tx_receipt_get_size((const dap_chain_datum_tx_receipt_t*) a_item);
@@ -141,7 +162,7 @@ size_t dap_chain_datum_item_tx_get_size(const uint8_t *a_item)
size = dap_chain_tx_out_cond_get_size((const dap_chain_tx_out_cond_t*) a_item);
break;
case TX_ITEM_TYPE_256_OUT_COND: // 256
- size = dap_chain_tx_out_cond_get_size((const dap_chain_tx_out_cond_t*) a_item);
+ size = dap_chain_256_tx_out_cond_get_size((const dap_chain_256_tx_out_cond_t*) a_item);
break;
case TX_ITEM_TYPE_PKEY: // Transaction public keys
size = dap_chain_tx_pkey_get_size((const dap_chain_tx_pkey_t*) a_item);
@@ -241,13 +262,13 @@ dap_chain_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a
}
//256
-dap_chain_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value)
+dap_chain_256_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value)
{
if(!a_addr)
return NULL;
- dap_chain_tx_out_t *l_item = DAP_NEW_Z(dap_chain_tx_out_t);
+ dap_chain_256_tx_out_t *l_item = DAP_NEW_Z(dap_chain_256_tx_out_t);
l_item->header.type = TX_ITEM_TYPE_256_OUT;
- l_item->header.value_256 = a_value;
+ l_item->header.value = a_value;
memcpy(&l_item->addr, a_addr, sizeof(dap_chain_addr_t));
return l_item;
}
@@ -265,13 +286,13 @@ dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_a
}
//256
-dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
+dap_chain_256_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token)
{
if (!a_addr || !a_token)
return NULL;
- dap_chain_tx_out_ext_t *l_item = DAP_NEW_Z(dap_chain_tx_out_ext_t);
+ dap_chain_256_tx_out_ext_t *l_item = DAP_NEW_Z(dap_chain_256_tx_out_ext_t);
l_item->header.type = TX_ITEM_TYPE_256_OUT_EXT;
- l_item->header.value_256 = a_value;
+ l_item->header.value = a_value;
memcpy(&l_item->addr, a_addr, sizeof(dap_chain_addr_t));
strcpy(l_item->token, a_token);
return l_item;
@@ -310,7 +331,7 @@ dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_pay(dap_enc
}
// 256
-dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
+dap_chain_256_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
uint256_t a_value,uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
const void *a_params, size_t a_params_size)
{
@@ -320,16 +341,16 @@ dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap
uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_key, &l_pub_key_size);
- dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, sizeof(dap_chain_tx_out_cond_t) + a_params_size);
+ dap_chain_256_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_256_tx_out_cond_t, sizeof(dap_chain_256_tx_out_cond_t) + a_params_size);
if(l_item == NULL)
return NULL;
l_item->header.item_type = TX_ITEM_TYPE_256_OUT_COND;
- l_item->header.value_256 = a_value;
+ l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY; // By default creatre cond for service pay. Rework with smth more flexible
l_item->subtype.srv_pay.srv_uid = a_srv_uid;
l_item->subtype.srv_pay.unit = a_unit;
- l_item->subtype.srv_pay.unit_price_max_datoshi_256 = a_value_max_per_unit;
+ l_item->subtype.srv_pay.unit_price_max_datoshi = a_value_max_per_unit;
dap_hash_fast( l_pub_key, l_pub_key_size, & l_item->subtype.srv_pay.pkey_hash);
l_item->params_size = (uint32_t)a_params_size;
memcpy(l_item->params, a_params, a_params_size);
@@ -360,16 +381,16 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_xchange(dap
}
// 256
-dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid, dap_chain_net_id_t a_net_id,
+dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid, dap_chain_net_id_t a_net_id,
const char *a_token, uint256_t a_value,
const void *a_params, uint32_t a_params_size)
{
if (!a_token) {
return NULL;
}
- dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, sizeof(dap_chain_tx_out_cond_t) + a_params_size);
+ dap_chain_256_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_256_tx_out_cond_t, sizeof(dap_chain_256_tx_out_cond_t) + a_params_size);
l_item->header.item_type = TX_ITEM_TYPE_256_OUT_COND;
- l_item->header.value_256 = a_value;
+ l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE;
l_item->subtype.srv_xchange.srv_uid = a_srv_uid;
l_item->subtype.srv_xchange.net_id = a_net_id;
@@ -401,13 +422,13 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_c
}
// 256
-dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
+dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
const void *a_params, uint32_t a_params_size)
{
- dap_chain_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_tx_out_cond_t, sizeof(dap_chain_tx_out_cond_t) + a_params_size);
+ dap_chain_256_tx_out_cond_t *l_item = DAP_NEW_Z_SIZE(dap_chain_256_tx_out_cond_t, sizeof(dap_chain_256_tx_out_cond_t) + a_params_size);
l_item->header.item_type = TX_ITEM_TYPE_256_OUT_COND;
- l_item->header.value_256 = a_value;
+ l_item->header.value = a_value;
l_item->header.subtype = DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE;
l_item->subtype.srv_stake.srv_uid = a_srv_uid;
l_item->subtype.srv_stake.fee_value = a_fee_value;
@@ -548,11 +569,11 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a
}
// 256
-dap_chain_tx_out_cond_t *dap_chain_datum_256_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num)
+dap_chain_256_tx_out_cond_t *dap_chain_datum_256_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num)
{
dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
int l_prev_cond_idx = l_list_out_items ? 0 : -1;
- dap_chain_tx_out_cond_t *l_res = NULL;
+ dap_chain_256_tx_out_cond_t *l_res = NULL;
for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_prev_cond_idx++) {
if (*(uint8_t *)l_list_tmp->data == TX_ITEM_TYPE_256_OUT_COND) {
l_res = l_list_tmp->data;
diff --git a/modules/common/include/dap_chain_datum_token.h b/modules/common/include/dap_chain_datum_token.h
index 20a75ba505..cb55e26b95 100644
--- a/modules/common/include/dap_chain_datum_token.h
+++ b/modules/common/include/dap_chain_datum_token.h
@@ -210,7 +210,6 @@ typedef struct dap_chain_datum_token_emission{
struct {
uint8_t version;
uint8_t type; // Emission Type
- bool type_value_256;
char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
dap_chain_addr_t address; // Emission holder's address
union {
@@ -248,14 +247,21 @@ typedef struct dap_chain_datum_token_emission{
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO 0x02
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER 0x03
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT 0x04
+// 256
+#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_UNDEFINED 0x05
+#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH 0x06
+#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ALGO 0x07
+#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ATOM_OWNER 0x08
+#define DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_SMART_CONTRACT 0x09
extern const char *c_dap_chain_datum_token_emission_type_str[];
/// TDS op funcs
-///
-
dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, size_t a_token_size);
void dap_chain_datum_token_flags_dump(dap_string_t * a_str_out, uint16_t a_flags);
void dap_chain_datum_token_certs_dump(dap_string_t * a_str_out, byte_t * a_data_n_tsd, size_t a_certs_size);
dap_sign_t ** dap_chain_datum_token_simple_signs_parse(dap_chain_datum_token_t * a_datum_token, size_t a_datum_token_size, size_t *a_signs_count, size_t * a_signs_valid);
dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emission_serial, size_t *a_emission_size);
size_t dap_chain_datum_emission_get_size(uint8_t *a_emission_serial);
+
+// 256 TYPE
+bool dap_chain_datum_token_emission_is_type_256(uint8_t a_em_type);
diff --git a/modules/common/include/dap_chain_datum_tx_items.h b/modules/common/include/dap_chain_datum_tx_items.h
index d5425f70b3..007d3ed0fe 100644
--- a/modules/common/include/dap_chain_datum_tx_items.h
+++ b/modules/common/include/dap_chain_datum_tx_items.h
@@ -107,7 +107,7 @@ dap_chain_tx_in_cond_t* dap_chain_datum_tx_item_in_cond_create(dap_chain_hash_fa
dap_chain_tx_out_t* dap_chain_datum_tx_item_out_create(const dap_chain_addr_t *a_addr, uint64_t a_value);
// 256
-dap_chain_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value);
+dap_chain_256_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_t *a_addr, uint256_t a_value);
/**
* Create item dap_chain_tx_out_ext_t
@@ -117,7 +117,7 @@ dap_chain_tx_out_t* dap_chain_datum_tx_item_256_out_create(const dap_chain_addr_
dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_out_ext_create(const dap_chain_addr_t *a_addr, uint64_t a_value, const char *a_token);
// 256
-dap_chain_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token);
+dap_chain_256_tx_out_ext_t* dap_chain_datum_tx_item_256_out_ext_create(const dap_chain_addr_t *a_addr, uint256_t a_value, const char *a_token);
/**
* Create item dap_chain_tx_out_cond_t
@@ -128,7 +128,7 @@ dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_pay(dap_enc
uint64_t a_value, uint64_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
const void *a_cond, size_t a_cond_size);
// 256
-dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
+dap_chain_256_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_pay(dap_enc_key_t *a_key, dap_chain_net_srv_uid_t a_srv_uid,
uint256_t a_value, uint256_t a_value_max_per_unit, dap_chain_net_srv_price_unit_uid_t a_unit,
const void *a_cond, size_t a_cond_size);
/**
@@ -140,7 +140,7 @@ dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_out_cond_create_srv_xchange(dap
dap_chain_net_id_t a_net_id, const char *a_token, uint64_t a_value,
const void *a_params, uint32_t a_params_size);
//256
-dap_chain_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid,
+dap_chain_256_tx_out_cond_t* dap_chain_datum_tx_item_256_out_cond_create_srv_xchange(dap_chain_net_srv_uid_t a_srv_uid,
dap_chain_net_id_t a_net_id, const char *a_token, uint256_t a_value,
const void *a_params, uint32_t a_params_size);
@@ -154,7 +154,7 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_out_cond_create_srv_stake(dap_c
dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
const void *a_params, uint32_t a_params_size);
// 256
-dap_chain_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
+dap_chain_256_tx_out_cond_t *dap_chain_datum_tx_item_256_out_cond_create_srv_stake(dap_chain_net_srv_uid_t a_srv_uid, uint256_t a_value, long double a_fee_value,
dap_chain_addr_t *a_fee_addr, dap_chain_addr_t *a_hldr_addr,
const void *a_params, uint32_t a_params_size);
/**
@@ -187,4 +187,4 @@ uint8_t* dap_chain_datum_tx_item_get( dap_chain_datum_tx_t *a_tx, int *a_item_id
dap_list_t* dap_chain_datum_tx_items_get(dap_chain_datum_tx_t *a_tx, dap_chain_tx_item_type_t a_type, int *a_item_count);
// Get conditional out item with it's idx
dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num);
-dap_chain_tx_out_cond_t *dap_chain_datum_256_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num);
+dap_chain_256_tx_out_cond_t *dap_chain_datum_256_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, int *a_out_num);
diff --git a/modules/common/include/dap_chain_datum_tx_out.h b/modules/common/include/dap_chain_datum_tx_out.h
index 37c18c0e54..0394a74ef6 100644
--- a/modules/common/include/dap_chain_datum_tx_out.h
+++ b/modules/common/include/dap_chain_datum_tx_out.h
@@ -35,11 +35,17 @@
typedef struct dap_chain_tx_out{
struct {
dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
- union {
- uint64_t value; /// @param value @brief Number of Datoshis ( DAP/10^9 ) to be transfered
- uint256_t value_256;
- };
+ uint64_t value; /// @param value @brief Number of Datoshis ( DAP/10^9 ) to be transfered
} header; /// Only header's hash is used for verification
dap_chain_addr_t addr; ////
} DAP_ALIGN_PACKED dap_chain_tx_out_t;
+//256
+typedef struct dap_chain_256_tx_out{
+ struct {
+ dap_chain_tx_item_type_t type:8; /// @param type @brief Transaction item type
+ uint256_t value; /// @param value @brief Number of Datoshis ( DAP/10^9 ) to be transfered
+ } header; /// Only header's hash is used for verification
+ dap_chain_addr_t addr; ////
+} DAP_ALIGN_PACKED dap_chain_256_tx_out_t;
+
diff --git a/modules/common/include/dap_chain_datum_tx_out_cond.h b/modules/common/include/dap_chain_datum_tx_out_cond.h
index e90701767a..1bbd166f0a 100644
--- a/modules/common/include/dap_chain_datum_tx_out_cond.h
+++ b/modules/common/include/dap_chain_datum_tx_out_cond.h
@@ -57,10 +57,7 @@ typedef struct dap_chain_tx_out_cond {
/// Condition subtype
dap_chain_tx_out_cond_subtype_t subtype : 8;
/// Number of Datoshis ( DAP/10^9 ) to be reserver for service
- union {
- uint64_t value;
- uint256_t value_256;
- };
+ uint64_t value;
/// When time expires this output could be used only by transaction owner
dap_chain_time_t ts_expires;
} header;
@@ -74,10 +71,7 @@ typedef struct dap_chain_tx_out_cond {
/// Price unit thats used to check price max
dap_chain_net_srv_price_unit_uid_t unit;
/// Maximum price per unit
- union {
- uint64_t unit_price_max_datoshi;
- uint256_t unit_price_max_datoshi_256;
- };
+ uint64_t unit_price_max_datoshi;
} srv_pay;
struct {
// Service uid that only could be used for this outout
@@ -87,10 +81,7 @@ typedef struct dap_chain_tx_out_cond {
// Chain network to change to
dap_chain_net_id_t net_id;
// Total amount of datoshi to change to
- union {
- uint64_t value;
- uint256_t value_256;
- };
+ uint64_t value;
} srv_xchange;
struct {
// Service uid that only could be used for this outout
@@ -106,3 +97,60 @@ typedef struct dap_chain_tx_out_cond {
uint32_t params_size; // Condition parameters size
uint8_t params[]; // condition parameters, pkey, hash or smth like this
} DAP_ALIGN_PACKED dap_chain_tx_out_cond_t;
+
+
+/**
+ * @struct dap_chain_tx_out
+ * @brief Transaction item out_cond
+ */
+typedef struct dap_chain_256_tx_out_cond {
+ struct {
+ /// Transaction item type
+ dap_chain_tx_item_type_t item_type :8;
+ /// Condition subtype
+ dap_chain_tx_out_cond_subtype_t subtype : 8;
+ /// Number of Datoshis ( DAP/10^9 ) to be reserver for service
+ uint256_t value;
+ /// When time expires this output could be used only by transaction owner
+ dap_chain_time_t ts_expires;
+ } header;
+ union {
+ /// Structure with specific for service pay condition subtype
+ struct {
+ /// Public key hash that could use this conditioned outout
+ dap_chain_hash_fast_t pkey_hash;
+ /// Service uid that only could be used for this outout
+ dap_chain_net_srv_uid_t srv_uid;
+ /// Price unit thats used to check price max
+ dap_chain_net_srv_price_unit_uid_t unit;
+ /// Maximum price per unit
+ uint256_t unit_price_max_datoshi;
+ } srv_pay;
+ struct {
+ // Service uid that only could be used for this outout
+ dap_chain_net_srv_uid_t srv_uid;
+ // Token ticker to change to
+ char token[DAP_CHAIN_TICKER_SIZE_MAX];
+ // Chain network to change to
+ dap_chain_net_id_t net_id;
+ // Total amount of datoshi to change to
+ uint256_t value;
+ } srv_xchange;
+ struct {
+ // Service uid that only could be used for this outout
+ dap_chain_net_srv_uid_t srv_uid;
+ // Stake holder address
+ dap_chain_addr_t hldr_addr;
+ // Fee address
+ dap_chain_addr_t fee_addr;
+ // Fee value in percent
+ long double fee_value;
+ } srv_stake;
+ } subtype;
+ uint32_t params_size; // Condition parameters size
+ uint8_t params[]; // condition parameters, pkey, hash or smth like this
+} DAP_ALIGN_PACKED dap_chain_256_tx_out_cond_t;
+
+
+
+
diff --git a/modules/common/include/dap_chain_datum_tx_out_ext.h b/modules/common/include/dap_chain_datum_tx_out_ext.h
index 400a61f68f..1a310068cb 100644
--- a/modules/common/include/dap_chain_datum_tx_out_ext.h
+++ b/modules/common/include/dap_chain_datum_tx_out_ext.h
@@ -36,11 +36,18 @@
typedef struct dap_chain_tx_out_ext{
struct {
dap_chain_tx_item_type_t type : 8; // Transaction item type - should be TX_ITEM_TYPE_OUT_EXT
- union {
- uint64_t value; // Number of Datoshis ( DAP/10^9 ) to be transfered
- uint256_t value_256;
- };
+ uint64_t value; // Number of Datoshis ( DAP/10^9 ) to be transfered
} header; // Only header's hash is used for verification
dap_chain_addr_t addr; // Address to transfer to
char token[DAP_CHAIN_TICKER_SIZE_MAX]; // Which token is transferred
} DAP_ALIGN_PACKED dap_chain_tx_out_ext_t;
+
+// 256
+typedef struct dap_chain_256_tx_out_ext{
+ struct {
+ dap_chain_tx_item_type_t type : 8; // Transaction item type - should be TX_ITEM_TYPE_OUT_EXT
+ uint256_t value; // Number of Datoshis ( DAP/10^9 ) to be transfered
+ } header; // Only header's hash is used for verification
+ dap_chain_addr_t addr; // Address to transfer to
+ char token[DAP_CHAIN_TICKER_SIZE_MAX]; // Which token is transferred
+} DAP_ALIGN_PACKED dap_chain_256_tx_out_ext_t;
diff --git a/modules/consensus/none/dap_chain_cs_none.c b/modules/consensus/none/dap_chain_cs_none.c
index 99cec6bd62..1ed333c0b7 100644
--- a/modules/consensus/none/dap_chain_cs_none.c
+++ b/modules/consensus/none/dap_chain_cs_none.c
@@ -323,10 +323,10 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
}break;
case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
- l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- true : false;
- if (dap_chain_ledger_token_emission_load(a_chain->ledger, l_token_em, l_datum->header.data_size))
+ // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
+ // l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
+ // true : false;
+ if (dap_chain_ledger_token_emission_load(a_chain->ledger, (dap_chain_datum_token_emission_t*) l_datum->data, l_datum->header.data_size))
return ATOM_REJECT;
}break;
case DAP_CHAIN_DATUM_256_TX: // 256
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index afce48cf13..465c74a5a9 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -2555,10 +2555,10 @@ int dap_chain_net_verify_datum_for_add(dap_chain_net_t *a_net, dap_chain_datum_t
case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) a_datum->data;
- l_token_em->hdr.type_value_256 = a_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- true : false;
- return dap_chain_ledger_token_emission_add_check( a_net->pub.ledger, l_token_em, a_datum->header.data_size );
+ // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) a_datum->data;
+ // l_token_em->hdr.type_value_256 = a_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
+ // true : false;
+ return dap_chain_ledger_token_emission_add_check( a_net->pub.ledger, (dap_chain_datum_token_emission_t*) a_datum->data, a_datum->header.data_size );
}
default: return 0;
}
@@ -2795,27 +2795,40 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_hash_fast_to_str(&l_in->header.tx_prev_hash, l_tx_prev_hash_str, sizeof (l_tx_prev_hash_str)-1);
dap_string_append_printf(a_str_out,"\ttx_prev_hash : %s\n", l_tx_prev_hash_str );
} break;
- case TX_ITEM_TYPE_256_OUT: // 256
+ case TX_ITEM_TYPE_256_OUT: { // 256
+ dap_string_append_printf(a_str_out,"\tvalue: %s\n",
+ dap_chain_u256tostr(((dap_chain_256_tx_out_t *)l_cur->data)->header.value)
+ );
+ char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_256_tx_out_t *)l_cur->data)->addr );
+ dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
+ DAP_DELETE(l_addr_str);
+ } break;
case TX_ITEM_TYPE_OUT:{
- dap_chain_tx_out_t * l_out = l_cur->data;
- if ( l_item_type == TX_ITEM_TYPE_256_OUT ) // u256_t value
- dap_string_append_printf(a_str_out,"\tvalue: %s\n", dap_chain_u256tostr(l_out->header.value_256) );
- else // u64_t value
- dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n", l_out->header.value );
- char * l_addr_str = dap_chain_addr_to_str(&l_out->addr);
+ dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n",
+ ((dap_chain_tx_out_t *)l_cur->data)->header.value
+ );
+ char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_tx_out_t *)l_cur->data)->addr );
dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
DAP_DELETE(l_addr_str);
} break;
- case TX_ITEM_TYPE_256_OUT_EXT: // 256
+ case TX_ITEM_TYPE_256_OUT_EXT: { // 256
+ // dap_chain_256_tx_out_ext_t * l_out_ext = l_cur->data;
+ dap_string_append_printf(a_str_out,"\tvalue: %s\n",
+ dap_chain_u256tostr(((dap_chain_256_tx_out_ext_t *)l_cur->data)->header.value)
+ );
+ char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_256_tx_out_ext_t *)l_cur->data)->addr );
+ dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
+ dap_string_append_printf(a_str_out,"\ttoken : %s\n", ((dap_chain_256_tx_out_ext_t *)l_cur->data)->token );
+ DAP_DELETE(l_addr_str);
+ } break;
case TX_ITEM_TYPE_OUT_EXT:{
- dap_chain_tx_out_ext_t * l_out_ext = l_cur->data;
- if ( l_item_type == TX_ITEM_TYPE_256_OUT_EXT ) // u256_t value
- dap_string_append_printf(a_str_out,"\tvalue: %s\n", dap_chain_u256tostr(l_out_ext->header.value_256) );
- else
- dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n", l_out_ext->header.value );
- char * l_addr_str = dap_chain_addr_to_str(&l_out_ext->addr);
+ // dap_chain_tx_out_ext_t * l_out_ext = l_cur->data;
+ dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n",
+ ((dap_chain_tx_out_ext_t *)l_cur->data)->header.value
+ );
+ char * l_addr_str = dap_chain_addr_to_str( &((dap_chain_tx_out_ext_t *)l_cur->data)->addr );
dap_string_append_printf(a_str_out,"\taddr : %s\n", l_addr_str );
- dap_string_append_printf(a_str_out,"\ttoken : %s\n", l_out_ext->token );
+ dap_string_append_printf(a_str_out,"\ttoken : %s\n", ((dap_chain_tx_out_ext_t *)l_cur->data)->token );
DAP_DELETE(l_addr_str);
} break;
case TX_ITEM_TYPE_SIG:{
@@ -2860,13 +2873,44 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_hash_fast_to_str(&l_in->header.tx_prev_hash, l_tx_prev_hash_str,sizeof (l_tx_prev_hash_str)-1);
dap_string_append_printf(a_str_out,"\ttx_prev_hash : %s\n", l_tx_prev_hash_str );
} break;
- case TX_ITEM_TYPE_256_OUT_COND: // 256
+ case TX_ITEM_TYPE_256_OUT_COND: { // 256
+ dap_chain_256_tx_out_cond_t * l_out = l_cur->data;
+ dap_string_append_printf(a_str_out,"\tvalue: %s\n", dap_chain_u256tostr(l_out->header.value) );
+ switch ( l_out->header.subtype){
+ case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:{
+ dap_string_append_printf(a_str_out,"\tsubtype: DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY\n");
+ dap_string_append_printf(a_str_out,"\tsrv_uid: 0x%016"DAP_UINT64_FORMAT_x"\n", l_out->subtype.srv_pay.srv_uid.uint64 );
+ switch (l_out->subtype.srv_pay.unit.enm) {
+ case SERV_UNIT_UNDEFINED: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_UNDEFINED\n"); break;
+ case SERV_UNIT_MB: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_MB\n"); break;
+ case SERV_UNIT_SEC: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_SEC\n"); break;
+ case SERV_UNIT_DAY: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_DAY\n"); break;
+ case SERV_UNIT_KB: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_KB\n"); break;
+ case SERV_UNIT_B : dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_B\n"); break;
+ default: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_UNKNOWN\n"); break;
+ }
+ dap_string_append_printf(a_str_out,"\tunit_price_max: %s\n",
+ dap_chain_u256tostr(l_out->subtype.srv_pay.unit_price_max_datoshi)
+ );
+ char l_pkey_hash_str[70]={[0]='\0'};
+ dap_chain_hash_fast_to_str(&l_out->subtype.srv_pay.pkey_hash, l_pkey_hash_str, sizeof (l_pkey_hash_str)-1);
+ dap_string_append_printf(a_str_out,"\tpkey_hash: %s\n", l_pkey_hash_str );
+ }break;
+ case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE:{
+ dap_string_append_printf(a_str_out,"\tsubtype: DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE\n");
+ }break;
+ case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE:{
+ dap_string_append_printf(a_str_out,"\tsubtype: DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE\n");
+ }break;
+ default:{
+ dap_string_append_printf(a_str_out,"\tsubtype: UNKNOWN\n");
+ }break;
+ }
+ dap_string_append_printf(a_str_out,"\tparams_size : %u\n", l_out->params_size );
+ } break;
case TX_ITEM_TYPE_OUT_COND:{
dap_chain_tx_out_cond_t * l_out = l_cur->data;
- if ( l_item_type == TX_ITEM_TYPE_256_OUT_COND ) // u256_t value
- dap_string_append_printf(a_str_out,"\tvalue: %s\n", dap_chain_u256tostr(l_out->header.value_256) );
- else
- dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n", l_out->header.value );
+ dap_string_append_printf(a_str_out,"\tvalue: %"DAP_UINT64_FORMAT_U"\n", l_out->header.value );
switch ( l_out->header.subtype){
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:{
dap_string_append_printf(a_str_out,"\tsubtype: DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY\n");
@@ -2880,11 +2924,10 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
case SERV_UNIT_B : dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_B\n"); break;
default: dap_string_append_printf(a_str_out,"\tunit: SERV_UNIT_UNKNOWN\n"); break;
}
- if ( l_item_type == TX_ITEM_TYPE_256_OUT_COND ) // u256_t value
- dap_string_append_printf(a_str_out,"\tunit_price_max: %s\n", dap_chain_u256tostr(l_out->subtype.srv_pay.unit_price_max_datoshi_256));
- else
- dap_string_append_printf(a_str_out,"\tunit_price_max: %"DAP_UINT64_FORMAT_U"\n", l_out->subtype.srv_pay.unit_price_max_datoshi);
-
+ dap_string_append_printf(a_str_out,"\tunit_price_max: %"DAP_UINT64_FORMAT_U"\n",
+ l_out->subtype.srv_pay.unit_price_max_datoshi
+ );
+
char l_pkey_hash_str[70]={[0]='\0'};
dap_chain_hash_fast_to_str(&l_out->subtype.srv_pay.pkey_hash, l_pkey_hash_str, sizeof (l_pkey_hash_str)-1);
dap_string_append_printf(a_str_out,"\tpkey_hash: %s\n", l_pkey_hash_str );
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 0ca0fb95cd..8a73c4bf57 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -3308,17 +3308,19 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_emission_size);
if ( !l_type_256 ) {
- l_emission->hdr.type_value_256 = false;
+ l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
+ //l_emission->hdr.type_value_256 = false;
l_emission->hdr.value = dap_chain_uint256_to(l_emission_value);
} else { // 256
- l_emission->hdr.type_value_256 = true;
+ l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH;
+ //l_emission->hdr.type_value_256 = true;
l_emission->hdr.value_256 = l_emission_value;
}
l_emission->hdr.version = 1;
strncpy(l_emission->hdr.ticker, l_ticker, sizeof(l_emission->hdr.ticker) - 1);
- l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
+ // l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
memcpy(&l_emission->hdr.address, l_addr, sizeof(l_emission->hdr.address));
time_t l_time = time(NULL);
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index bd40a3fb9e..c239eaa07b 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -166,10 +166,10 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t Value: %s (%s)\n"
"\t\t Address: %s\n",
dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(
- ((dap_chain_tx_out_t*)item)->header.value_256)
+ ((dap_chain_256_tx_out_t*)item)->header.value)
),
- dap_chain_u256tostr(((dap_chain_tx_out_t*)item)->header.value_256),
- dap_chain_addr_to_str(&((dap_chain_tx_out_t*)item)->addr));
+ dap_chain_u256tostr(((dap_chain_256_tx_out_t*)item)->header.value),
+ dap_chain_addr_to_str(&((dap_chain_256_tx_out_t*)item)->addr));
break;
}
case TX_ITEM_TYPE_256_TOKEN:
@@ -373,27 +373,27 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t\t value: %s (%s)\n"
"\t\t\t subtype: %s\n"
"\t\t SubType:\n",
- dap_ctime_r((time_t*)((dap_chain_tx_out_cond_t*)item)->header.ts_expires, l_tmp_buf),
+ dap_ctime_r((time_t*)((dap_chain_256_tx_out_cond_t*)item)->header.ts_expires, l_tmp_buf),
dap_chain_balance_to_coins(
- dap_chain_uint128_from_uint256(((dap_chain_tx_out_cond_t*)item)->header.value_256)
+ dap_chain_uint128_from_uint256(((dap_chain_256_tx_out_cond_t*)item)->header.value)
),
- dap_chain_u256tostr(((dap_chain_tx_out_cond_t*)item)->header.value_256),
- dap_chain_tx_out_cond_subtype_to_str(((dap_chain_tx_out_cond_t*)item)->header.subtype)
+ dap_chain_u256tostr(((dap_chain_256_tx_out_cond_t*)item)->header.value),
+ dap_chain_tx_out_cond_subtype_to_str(((dap_chain_256_tx_out_cond_t*)item)->header.subtype)
);
- switch (((dap_chain_tx_out_cond_t*)item)->header.subtype) {
+ switch (((dap_chain_256_tx_out_cond_t*)item)->header.subtype) {
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:
- l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash);
+ l_hash_str_tmp = dap_chain_hash_fast_to_str_new(&((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.pkey_hash);
dap_string_append_printf(a_str_out, "\t\t\t unit: 0x%08x\n"
"\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t pkey: %s\n"
"\t\t\t max price: %s (%s) \n",
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit.uint32,
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.srv_uid.uint64,
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.unit.uint32,
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.srv_uid.uint64,
l_hash_str_tmp,
dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi_256)
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi)
),
- dap_chain_u256tostr(((dap_chain_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi_256)
+ dap_chain_u256tostr(((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_pay.unit_price_max_datoshi)
);
DAP_FREE(l_hash_str_tmp);
break;
@@ -401,11 +401,11 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
dap_string_append_printf(a_str_out, "\t\t\t uid: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t addr: %s\n"
"\t\t\t value: %Lf",
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.srv_uid.uint64,
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_stake.srv_uid.uint64,
dap_chain_addr_to_str(
- &((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.fee_addr
+ &((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_stake.fee_addr
),
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_stake.fee_value
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_stake.fee_value
);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE:
@@ -413,15 +413,15 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t\t net id: 0x%016"DAP_UINT64_FORMAT_x"\n"
"\t\t\t token: %s\n"
"\t\t\t value: %s (%s)\n",
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.srv_uid.uint64,
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.net_id.uint64,
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.token,
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.srv_uid.uint64,
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.net_id.uint64,
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.token,
dap_chain_balance_to_coins(
dap_chain_uint128_from_uint256(
- ((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.value_256
+ ((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.value
)
),
- dap_chain_u256tostr(((dap_chain_tx_out_cond_t*)item)->subtype.srv_xchange.value_256)
+ dap_chain_u256tostr(((dap_chain_256_tx_out_cond_t*)item)->subtype.srv_xchange.value)
);
break;
}
@@ -444,12 +444,12 @@ static void s_dap_chain_datum_tx_out_data(dap_chain_datum_tx_t *a_datum,
"\t\t Addr: %s\n"
"\t\t Token: %s\n"
"\t\t Value: %s (%s)\n",
- dap_chain_addr_to_str(&((dap_chain_tx_out_ext_t*)item)->addr),
- ((dap_chain_tx_out_ext_t*)item)->token,
+ dap_chain_addr_to_str(&((dap_chain_256_tx_out_ext_t*)item)->addr),
+ ((dap_chain_256_tx_out_ext_t*)item)->token,
dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(
- ((dap_chain_tx_out_ext_t*)item)->header.value_256)
+ ((dap_chain_256_tx_out_ext_t*)item)->header.value)
),
- dap_chain_u256tostr(((dap_chain_tx_out_ext_t*)item)->header.value_256)
+ dap_chain_u256tostr(((dap_chain_256_tx_out_ext_t*)item)->header.value)
);
break;
default:
@@ -552,21 +552,20 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
dap_list_t *l_list_tmp = l_list_out_items;
while(l_list_tmp) {
- // const dap_chain_256_tx_out_t *l_tx_out_256 = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
+ const dap_chain_256_tx_out_t *l_tx_out_256 = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
// save OUT item l_tx_out - only for first OUT item
- if(!l_tx_data)
- {
+ if(!l_tx_data) {
// save tx hash
l_tx_data = DAP_NEW_Z(dap_tx_data_t);
dap_chain_hash_fast_t l_tx_hash;
dap_hash_fast(l_tx, dap_chain_datum_tx_get_size(l_tx), &l_tx_hash);
memcpy(&l_tx_data->tx_hash, &l_tx_hash, sizeof(dap_chain_hash_fast_t));
- // if ( l_type_256 ) // 256
- // memcpy(&l_tx_data->addr, &l_tx_out->addr, sizeof(dap_chain_addr_t));
- // else
- memcpy(&l_tx_data->addr, &l_tx_out->addr, sizeof(dap_chain_addr_t));
+ if ( l_type_256 ) // 256
+ memcpy(&l_tx_data->addr, &l_tx_out->addr, sizeof(dap_chain_addr_t));
+ else
+ memcpy(&l_tx_data->addr, &l_tx_out_256->addr, sizeof(dap_chain_addr_t));
dap_chain_hash_fast_to_str(&l_tx_data->tx_hash, l_tx_data->tx_hash_str,
sizeof(l_tx_data->tx_hash_str));
@@ -642,20 +641,20 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
l_list_tmp = l_list_out_items;
while(l_list_tmp) {
- // const dap_chain_256_tx_out_t *l_tx_out_256 = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
+ const dap_chain_256_tx_out_t *l_tx_out_256 = (const dap_chain_256_tx_out_t*) l_list_tmp->data;
const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
//dap_tx_data_t *l_tx_data_prev = NULL;
const char *l_token_str = NULL;
if(l_tx_data)
l_token_str = l_tx_data->token_ticker;
- char *l_dst_to_str =
- (l_tx_out) ? dap_chain_addr_to_str(&l_tx_out->addr) : NULL;
+ char *l_dst_to_str = (l_tx_out) ? dap_chain_addr_to_str(&l_tx_out->addr) :
+ (l_tx_out_256) ? dap_chain_addr_to_str(&l_tx_out_256->addr) : NULL;
- if(l_tx_out) {
+ if(l_tx_out || l_tx_out_256) {
if ( l_type_256 ) // 256
dap_string_append_printf(l_str_out, " OUT 256_t item %s %s to %s\n",
- dap_chain_u256tostr(l_tx_out->header.value_256),
+ dap_chain_u256tostr(l_tx_out_256->header.value),
dap_strlen(l_token_str) > 0 ? l_token_str : "?",
l_dst_to_str ? l_dst_to_str : "?"
);
@@ -708,20 +707,18 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
// find OUT item for IN item;
dap_list_t *l_list_out_prev_item = dap_list_nth(l_list_out_prev_items,
l_tx_in->header.tx_out_prev_idx);
- dap_chain_tx_out_t *l_tx_prev_out =
- l_list_out_prev_item ? (dap_chain_tx_out_t*)l_list_out_prev_item->data :
- NULL;
+ dap_chain_256_tx_out_t *l_tx_prev_out =
+ l_list_out_prev_item ? (dap_chain_256_tx_out_t*)l_list_out_prev_item->data : NULL;
// print value from prev out item
dap_string_append_printf(l_str_out, " prev OUT 256_t item value=%s",
- l_tx_prev_out ? dap_chain_u256tostr(l_tx_prev_out->header.value_256) : "0");
+ l_tx_prev_out ? dap_chain_u256tostr(l_tx_prev_out->header.value) : "0");
} else {
dap_list_t *l_list_out_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
TX_ITEM_TYPE_OUT, NULL);
dap_list_t *l_list_out_prev_item = dap_list_nth(l_list_out_prev_items,
l_tx_in->header.tx_out_prev_idx);
dap_chain_tx_out_t *l_tx_prev_out =
- l_list_out_prev_item ? (dap_chain_tx_out_t*)l_list_out_prev_item->data :
- NULL;
+ l_list_out_prev_item ? (dap_chain_tx_out_t*)l_list_out_prev_item->data : NULL;
dap_string_append_printf(l_str_out, " prev OUT item value=%"DAP_UINT64_FORMAT_U,
l_tx_prev_out ? l_tx_prev_out->header.value : 0);
}
@@ -1388,7 +1385,7 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
break;
}
- if ( l_token_em->hdr.type_value_256 ) { // 256
+ if ( dap_chain_datum_token_emission_is_type_256(l_token_em->hdr.type) ) { // 256
dap_string_append_printf(l_str_out, "emission 256: %.0Lf(%s) %s, type: %s, version: %d\n",
dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token_em->hdr.value_256)),
dap_chain_u256tostr(l_token_em->hdr.value_256),
@@ -1407,38 +1404,43 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
DAP_DELETE(l_token_emission_address_str);
switch (l_token_em->hdr.type) {
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:
- dap_string_append_printf(l_str_out, " signs_count: %d\n", l_token_em->data.type_auth.signs_count);
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
- dap_string_append_printf(l_str_out, " codename: %s\n", l_token_em->data.type_algo.codename);
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_UNDEFINED:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_AUTH: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH:
+ dap_string_append_printf(l_str_out, " signs_count: %d\n", l_token_em->data.type_auth.signs_count);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ALGO: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ALGO:
+ dap_string_append_printf(l_str_out, " codename: %s\n", l_token_em->data.type_algo.codename);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_ATOM_OWNER: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
+ if ( dap_chain_datum_token_emission_is_type_256(l_token_em->hdr.type) ) { // 256
+ dap_string_append_printf(l_str_out, " value_start: %s(%s), codename: %s\n",
+ dap_chain_datoshi_to_coins(dap_chain_uint128_from_uint256(l_token_em->data.type_atom_owner.value_start_256)),
+ dap_chain_u256tostr(l_token_em->data.type_atom_owner.value_start_256),
+ l_token_em->data.type_atom_owner.value_change_algo_codename
+ );
+ } else {
+ dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
+ dap_chain_datoshi_to_coins(l_token_em->data.type_atom_owner.value_start),
+ l_token_em->data.type_atom_owner.value_start,
+ l_token_em->data.type_atom_owner.value_change_algo_codename
+ );
+ }
break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_ATOM_OWNER:
- if ( l_token_em->hdr.type_value_256 ) { // 256
- dap_string_append_printf(l_str_out, " value_start: %s(%s), codename: %s\n",
- dap_chain_datoshi_to_coins(dap_chain_uint128_from_uint256(l_token_em->data.type_atom_owner.value_start_256)),
- dap_chain_u256tostr(l_token_em->data.type_atom_owner.value_start_256),
- l_token_em->data.type_atom_owner.value_change_algo_codename
- );
- } else {
- dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
- dap_chain_datoshi_to_coins(l_token_em->data.type_atom_owner.value_start),
- l_token_em->data.type_atom_owner.value_start,
- l_token_em->data.type_atom_owner.value_change_algo_codename
- );
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_SMART_CONTRACT:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT: {
+ char *l_addr = dap_chain_addr_to_str(&l_token_em->data.type_presale.addr);
+ // get time of create datum
+ if(dap_time_to_str_rfc822(l_time_str, 71, l_token_em->data.type_presale.lock_time) < 1)
+ l_time_str[0] = '\0';
+ dap_string_append_printf(l_str_out, " flags: 0x%x, lock_time: %s\n", l_token_em->data.type_presale.flags, l_time_str);
+ dap_string_append_printf(l_str_out, " addr: %s\n", l_addr);
+ DAP_DELETE(l_addr);
}
- break;
- case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT: {
- char *l_addr = dap_chain_addr_to_str(&l_token_em->data.type_presale.addr);
- // get time of create datum
- if(dap_time_to_str_rfc822(l_time_str, 71, l_token_em->data.type_presale.lock_time) < 1)
- l_time_str[0] = '\0';
- dap_string_append_printf(l_str_out, " flags: 0x%x, lock_time: %s\n", l_token_em->data.type_presale.flags, l_time_str);
- dap_string_append_printf(l_str_out, " addr: %s\n", l_addr);
- DAP_DELETE(l_addr);
- }
break;
}
dap_string_append_printf(l_str_out, "\n");
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 6189692086..fc189647ed 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -624,10 +624,10 @@ static int s_add_atom_to_ledger(dap_chain_cs_blocks_t * a_blocks, dap_ledger_t
} break;
case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
- l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- true : false;
- l_ret=dap_chain_ledger_token_emission_load(a_ledger, l_token_em, l_datum->header.data_size);
+ // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
+ // l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
+ // true : false;
+ l_ret=dap_chain_ledger_token_emission_load(a_ledger, (dap_chain_datum_token_emission_t*) l_datum->data, l_datum->header.data_size);
} break;
case DAP_CHAIN_DATUM_TX: {
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 9434252e15..a760bc626e 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -305,10 +305,10 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
break;
case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
- l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- true : false;
- return dap_chain_ledger_token_emission_load(a_ledger, l_token_em, l_datum->header.data_size);
+ // dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
+ // l_token_em->hdr.type_value_256 = l_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
+ // true : false;
+ return dap_chain_ledger_token_emission_load(a_ledger, (dap_chain_datum_token_emission_t*) l_datum->data, l_datum->header.data_size);
}
break;
case DAP_CHAIN_DATUM_256_TX: // 256
--
GitLab