diff --git a/dap-sdk/core/include/dap_math_ops.h b/dap-sdk/core/include/dap_math_ops.h
index f3f3061f34d5d22a47d5b5595c63fa02f89265b1..946a6be6a7d73a15f754e79674d421c7779df43f 100755
--- a/dap-sdk/core/include/dap_math_ops.h
+++ b/dap-sdk/core/include/dap_math_ops.h
@@ -143,8 +143,7 @@ static inline bool EQUAL_256(uint256_t a_256_bit, uint256_t b_256_bit){
}
static inline bool IS_ZERO_256(uint256_t a_256_bit){
-
- return a_256_bit.lo == (uint128_t)0;
+ return EQUAL_256(a_256_bit, uint256_0);//a_256_bit.lo == (uint128_t)0;
}
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index b5037d19a34ce23c7736fc7f2e7a9cfaad05e064..edda63085b9aa08e4508c50ef460ee9ffd2a5bfa 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -248,18 +248,21 @@ static dap_chain_type_t s_chain_type_from_str(const char *a_type_str)
if(!dap_strcmp(a_type_str, "token")) {
return CHAIN_TYPE_TOKEN;
}
+ // if(!dap_strcmp(a_type_str, "token_256")) {
+ // return CHAIN_TYPE_256_TOKEN;
+ // }
if(!dap_strcmp(a_type_str, "emission")) {
return CHAIN_TYPE_EMISSION;
}
- if(!dap_strcmp(a_type_str, "emission_256")) {
- return CHAIN_TYPE_256_EMISSION;
- }
+ // if(!dap_strcmp(a_type_str, "emission_256")) {
+ // return CHAIN_TYPE_256_EMISSION;
+ // }
if(!dap_strcmp(a_type_str, "transaction")) {
return CHAIN_TYPE_TX;
}
- if(!dap_strcmp(a_type_str, "transaction_256")) {
- return CHAIN_TYPE_256_TX;
- }
+ // if(!dap_strcmp(a_type_str, "transaction_256")) {
+ // return CHAIN_TYPE_256_TX;
+ // }
if(!dap_strcmp(a_type_str, "ca")) {
return CHAIN_TYPE_CA;
}
@@ -274,19 +277,22 @@ static dap_chain_type_t s_chain_type_from_str(const char *a_type_str)
*/
static uint16_t s_datum_type_from_str(const char *a_type_str)
{
+ // if(!dap_strcmp(a_type_str, "token")) { // old
+ // return DAP_CHAIN_DATUM_TOKEN_DECL;
+ // }
if(!dap_strcmp(a_type_str, "token")) {
- return DAP_CHAIN_DATUM_TOKEN_DECL;
+ return DAP_CHAIN_DATUM_256_TOKEN_DECL;
}
+ // if(!dap_strcmp(a_type_str, "emission")) {
+ // return DAP_CHAIN_DATUM_TOKEN_EMISSION;
+ // }
if(!dap_strcmp(a_type_str, "emission")) {
- return DAP_CHAIN_DATUM_TOKEN_EMISSION;
- }
- if(!dap_strcmp(a_type_str, "emission_256")) {
return DAP_CHAIN_DATUM_256_TOKEN_EMISSION;
}
+ // if(!dap_strcmp(a_type_str, "transaction")) {
+ // return DAP_CHAIN_DATUM_TX;
+ // }
if(!dap_strcmp(a_type_str, "transaction")) {
- return DAP_CHAIN_DATUM_TX;
- }
- if(!dap_strcmp(a_type_str, "transaction_256")) {
return DAP_CHAIN_DATUM_256_TX;
}
return DAP_CHAIN_DATUM_CUSTOM;
@@ -301,15 +307,17 @@ static uint16_t s_datum_type_from_str(const char *a_type_str)
static uint16_t s_chain_type_convert(dap_chain_type_t a_type)
{
switch (a_type) {
- case CHAIN_TYPE_TOKEN:
- return DAP_CHAIN_DATUM_TOKEN_DECL;
+ case CHAIN_TYPE_TOKEN:
+ // return DAP_CHAIN_DATUM_TOKEN_DECL;
+ // case CHAIN_TYPE_256_TOKEN:
+ return DAP_CHAIN_DATUM_256_TOKEN_DECL;
case CHAIN_TYPE_EMISSION:
- return DAP_CHAIN_DATUM_TOKEN_EMISSION;
- case CHAIN_TYPE_256_EMISSION:
+ // return DAP_CHAIN_DATUM_TOKEN_EMISSION;
+ // case CHAIN_TYPE_256_EMISSION: // 256
return DAP_CHAIN_DATUM_256_TOKEN_EMISSION;
case CHAIN_TYPE_TX:
- return DAP_CHAIN_DATUM_TX;
- case CHAIN_TYPE_256_TX:
+ // return DAP_CHAIN_DATUM_TX;
+ // case CHAIN_TYPE_256_TX: // 256
return DAP_CHAIN_DATUM_256_TX;
default:
return DAP_CHAIN_DATUM_CUSTOM;
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 69262d327348d8ede447d815d48bec5aa210afc0..ba54cceed23c06d607448a2840580fee99ce8e4d 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -83,8 +83,15 @@ typedef struct dap_chain_ledger_token_item {
uint16_t type;
dap_chain_datum_token_t * datum_token;
- uint64_t total_supply;
- uint64_t current_supply;
+ //union {
+ // uint64_t total_supply;
+ uint256_t total_supply; // 256
+ //};
+ // union {
+ // uint64_t current_supply;
+ uint256_t current_supply;
+ //};
+
pthread_rwlock_t token_emissions_rwlock;
dap_chain_ledger_token_emission_item_t * token_emissions;
@@ -121,7 +128,7 @@ typedef struct dap_chain_ledger_tx_item {
} dap_chain_ledger_tx_item_t;
typedef struct dap_chain_ledger_tokenizer {
- bool type_256;
+ // bool type_256;
char token_ticker[10];
uint64_t sum;
UT_hash_handle hh;
@@ -144,6 +151,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;
@@ -384,40 +395,64 @@ int dap_chain_ledger_token_add(dap_ledger_t * a_ledger, dap_chain_datum_token_t
DAP_DELETE(l_gdb_group);
l_token_item->type = a_token->type;
switch(a_token->type){
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: {
- l_token_item->total_supply = a_token->header_private.total_supply;\
- l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
- &l_token_item->auth_signs_total,
- &l_token_item->auth_signs_valid );
- if(l_token_item->auth_signs_total){
- l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,sizeof (dap_chain_hash_fast_t)* l_token_item->auth_signs_total);
- for(uint16_t k=0; k<l_token_item->auth_signs_total;k++){
- dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: {// 256
+ l_token_item->total_supply = a_token->header_private.total_supply_256;
+ l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
+ &l_token_item->auth_signs_total,
+ &l_token_item->auth_signs_valid );
+ if(l_token_item->auth_signs_total){
+ l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,sizeof (dap_chain_hash_fast_t)* l_token_item->auth_signs_total);
+ for(uint16_t k=0; k<l_token_item->auth_signs_total;k++){
+ dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
+ }
+ if(s_debug_more)
+ log_it(L_NOTICE, "Simple token %s added (total_supply = %s total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE )",
+ a_token->ticker, dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(a_token->header_private.total_supply_256)),
+ a_token->header_private.signs_valid, a_token->header_private.signs_total);
+ }
+ break;
+ }
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
+ l_token_item->total_supply = GET_256_FROM_64(a_token->header_private.total_supply);
+ l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
+ &l_token_item->auth_signs_total,
+ &l_token_item->auth_signs_valid );
+ if(l_token_item->auth_signs_total){
+ l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,sizeof (dap_chain_hash_fast_t)* l_token_item->auth_signs_total);
+ for(uint16_t k=0; k<l_token_item->auth_signs_total;k++){
+ dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
+ }
+ if(s_debug_more)
+ log_it(L_NOTICE, "Simple token %s added (total_supply = %.1Lf total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE )",
+ a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_private.total_supply),
+ a_token->header_private.signs_valid, a_token->header_private.signs_total);
}
+ break;
+ }
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
if(s_debug_more)
- log_it(L_NOTICE, "Simple token %s added (total_supply = %.1Lf total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_PRIVATE )",
- a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_private.total_supply),
- a_token->header_private.signs_valid, a_token->header_private.signs_total);
+ log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL ", a_token->ticker);
+ s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL: {
+ if(s_debug_more)
+ log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL ", a_token->ticker);
+ s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
+ break;
}
- break;
- }
-
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: {
- if(s_debug_more)
- log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_PRIVATE_DECL ", a_token->ticker);
- s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
- break;
- }
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: {
- if(s_debug_more)
- log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
- // TODO: Check authorithy
- //s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
- break;
- }
- default:
- if(s_debug_more)
- log_it(L_WARNING,"Unknown token declaration type 0x%04X", a_token->type );
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
+ if(s_debug_more)
+ log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ if(s_debug_more)
+ log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
+ // TODO: Check authorithy
+ //s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
+ break;
+ default:
+ if(s_debug_more)
+ log_it(L_WARNING,"Unknown token declaration type 0x%04X", a_token->type );
}
// Proc emissions tresholds
s_treshold_emissions_proc( a_ledger);
@@ -465,8 +500,12 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
}break;
// set total supply
- case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY:{
- a_token_item->total_supply = dap_tsd_get_scalar(l_tsd,uint64_t);
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256:{ // 256
+ a_token_item->total_supply = dap_tsd_get_scalar(l_tsd,uint256_t);
+ }break;
+
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY:{ // 128
+ a_token_item->total_supply = GET_256_FROM_128(dap_tsd_get_scalar(l_tsd,uint128_t));
}break;
// Set total signs count value to set to be valid
@@ -891,23 +930,27 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger)
HASH_ITER(hh, PVT(a_ledger)->tokens, l_token_item, l_tmp_item) {
const char *l_type_str;
switch (l_token_item->type) {
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:
- l_type_str = "SIMPLE"; break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
- l_type_str = "PRIVATE_DECL"; break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
- l_type_str = "PRIVATE_UPDATE"; break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC:
- l_type_str = "PUBLIC";
- default:
- l_type_str = "UNKNOWN"; break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
+ l_type_str = "SIMPLE"; break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
+ l_type_str = "PRIVATE_DECL"; break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ l_type_str = "PRIVATE_UPDATE"; break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC:
+ l_type_str = "PUBLIC";
+ default:
+ l_type_str = "UNKNOWN"; break;
}
char *l_item_str = dap_strdup_printf("Token name '%s', type %s, flags %hu\n"
- "\tSupply (current/total) %"DAP_UINT64_FORMAT_U"/%"DAP_UINT64_FORMAT_U"\n"
+ "\tSupply (current/total) %s/%s \n"
"\tAuth signs (valid/total) %zu/%zu\n"
"\tTotal emissions %u\n",
&l_token_item->ticker, l_type_str, l_token_item->flags,
- l_token_item->current_supply, l_token_item->total_supply,
+ dap_chain_u256tostr(l_token_item->current_supply), dap_chain_u256tostr(l_token_item->total_supply),
l_token_item->auth_signs_valid, l_token_item->auth_signs_total,
HASH_COUNT(l_token_item->token_emissions));
l_ret_list = dap_list_append(l_ret_list, l_item_str);
@@ -989,11 +1032,21 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
dap_chain_ledger_token_item_t *l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
strncpy(l_token_item->ticker, l_objs[i].key, sizeof(l_token_item->ticker) - 1);
l_token_item->ticker[sizeof(l_token_item->ticker) - 1] = '\0';
- l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_objs[i].value_len);
- memcpy(l_token_item->datum_token, l_objs[i].value, l_objs[i].value_len);
+ // l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_objs[i].value_len);
+ // memcpy(l_token_item->datum_token, l_objs[i].value, l_objs[i].value_len);
+ size_t l_token_size = l_objs[i].value_len;
+ l_token_item->datum_token = dap_chain_datum_token_read(l_objs[i].value, &l_token_size);
pthread_rwlock_init(&l_token_item->token_emissions_rwlock, NULL);
- if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE) {
- l_token_item->total_supply = l_token_item->datum_token->header_private.total_supply;
+
+ // test tsd
+ // size_t signs_total = 0, signs_valid = 0, l_token_size_test = l_token_size - sizeof(dap_chain_datum_token_t) + sizeof(dap_chain_datum_token_old_t);
+ // dap_sign_t **sign = dap_chain_datum_token_simple_signs_parse( l_token_item->datum_token, l_token_size_test, &signs_total, &signs_valid);
+ // printf("---!!! dap_chain_ledger_load_cache() sign_type %d \n", ( (dap_sign_t *)sign[0])->header.type.type );
+
+ if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE) {
+ l_token_item->total_supply = GET_256_FROM_64(l_token_item->datum_token->header_private.total_supply);
+ } else if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE) {
+ l_token_item->total_supply = l_token_item->datum_token->header_private.total_supply_256;
}
HASH_ADD_STR(l_ledger_pvt->tokens, ticker, l_token_item);
if (i == l_objs_count - 1) {
@@ -1018,9 +1071,10 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
const char *c_token_ticker = ((dap_chain_datum_token_emission_t *)l_objs[i].value)->hdr.ticker;
dap_chain_ledger_token_item_t *l_token_item = NULL;
HASH_FIND_STR(l_ledger_pvt->tokens, c_token_ticker, l_token_item);
- l_emission_item->datum_token_emission = l_token_item
- ? dap_chain_datum_emission_read(l_objs[i].value, &l_emission_size)
- : DAP_DUP_SIZE(l_objs[i].value, l_objs[i].value_len);
+ // l_emission_item->datum_token_emission = l_token_item
+ // ? dap_chain_datum_emission_read(l_objs[i].value, &l_emission_size)
+ // : DAP_DUP_SIZE(l_objs[i].value, l_objs[i].value_len);
+ l_emission_item->datum_token_emission = dap_chain_datum_emission_read(l_objs[i].value, &l_emission_size);
l_emission_item->datum_token_emission_size = l_emission_size;
if (l_token_item) {
HASH_ADD(hh, l_token_item->token_emissions, datum_token_emission_hash,
@@ -1083,14 +1137,20 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
l_objs = dap_chain_global_db_gr_load(l_gdb_group, &l_objs_count);
for (size_t i = 0; i < l_objs_count; i++) {
dap_ledger_wallet_balance_t *l_balance_item = DAP_NEW_Z(dap_ledger_wallet_balance_t);
+ size_t l_v0_size = sizeof(uint128_t); // for old data
+
l_balance_item->key = DAP_NEW_Z_SIZE(char, strlen(l_objs[i].key) + 1);
strcpy(l_balance_item->key, l_objs[i].key);
char *l_ptr = strchr(l_balance_item->key, ' ');
if (l_ptr++) {
strcpy(l_balance_item->token_ticker, l_ptr);
}
- //l_balance_item->balance = *(uint128_t *)l_objs[i].value;
- l_balance_item->balance = *(uint256_t *)l_objs[i].value;
+ if ( l_v0_size == l_objs[i].value_len ) { // old data
+ l_balance_item->balance = uint256_0;
+ l_balance_item->balance.lo = *(uint128_t *)l_objs[i].value;
+ } else {
+ l_balance_item->balance = *(uint256_t *)l_objs[i].value;
+ }
HASH_ADD_KEYPTR(hh, l_ledger_pvt->balance_accounts, l_balance_item->key,
strlen(l_balance_item->key), l_balance_item);
}
@@ -1153,7 +1213,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 ( l_token_emission_item->datum_token_emission->hdr.version == 1 ) //&& l_token_emission_item->datum_token_emission->hdr.type_256 )
log_it(L_ERROR, "Can't add token emission datum of %s %s ( %s ): already present in cache",
dap_chain_u256tostr(l_token_emission_item->datum_token_emission->hdr.value_256), c_token_ticker, l_hash_str);
else
@@ -1169,6 +1229,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 +1268,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 ( l_emission->hdr.version == 1 ) // && l_emission->hdr.type_256 ) // 256
log_it(L_WARNING, "Emission of %s datoshi of %s:%s is wrong: only %u valid aproves when %u need",
dap_chain_u256tostr(l_emission->hdr.value_256), a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
else
@@ -1291,11 +1352,11 @@ 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
- log_it(L_NOTICE, "Added token emission datum to %s: type=%s value=%.1Lf token=%s to_addr=%s ",
+ if ( l_token_emission_item->datum_token_emission->hdr.version == 1 ) // && l_token_emission_item->datum_token_emission->hdr.type_256 )
+ log_it(L_NOTICE, "Added token emission datum to %s: type=%s value=%s token=%s to_addr=%s ",
l_token_item?"emissions cache":"emissions treshold",
c_dap_chain_datum_token_emission_type_str[ l_token_emission_item->datum_token_emission->hdr.type ] ,
- dap_chain_datoshi_to_coins(
+ dap_chain_balance_to_coins(
dap_chain_uint128_from_uint256(l_token_emission_item->datum_token_emission->hdr.value_256)
), c_token_ticker,
l_token_emission_address_str);
@@ -1315,7 +1376,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_t *)a_token_emission)->hdr.version == 1 ) // && ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.type_256 ) // 256
log_it(L_ERROR, "Duplicate token emission datum of %s %s ( %s )",
dap_chain_u256tostr(((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value_256), c_token_ticker, l_hash_str);
else
@@ -1761,14 +1822,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 +1867,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 +1895,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 +1932,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 +1954,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 +1979,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 +2036,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 +2133,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 +2160,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 +2187,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 +2507,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 +2529,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 +2553,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 +2673,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 +2715,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 +3136,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 +3145,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 +3166,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 +3175,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 +3465,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 +3480,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/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index 8f655b747d01d5031eedace2baa99f1b2f16673b..6925d627291f1202e534e3f0040bdb36412dec0a 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -88,16 +88,17 @@ typedef size_t (*dap_chain_callback_add_datums_with_group_t)(dap_chain_t * , dap
typedef void (*dap_chain_callback_notify_t)(void * a_arg, dap_chain_t *a_chain, dap_chain_cell_id_t a_id, void* a_atom, size_t a_atom_size); //change in chain happened
-typedef enum dap_chain_type
+typedef enum dap_chain_type
{
CHAIN_TYPE_FIRST,
CHAIN_TYPE_TOKEN,
CHAIN_TYPE_EMISSION,
- CHAIN_TYPE_256_EMISSION, // 256
CHAIN_TYPE_TX,
- CHAIN_TYPE_256_TX, // 256
CHAIN_TYPE_CA,
CHAIN_TYPE_LAST
+ // CHAIN_TYPE_256_TOKEN, // 256
+ // CHAIN_TYPE_256_EMISSION, // 256
+ // CHAIN_TYPE_256_TX, // 256
} dap_chain_type_t;
typedef struct dap_chain{
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 140a22e8cdb33b3751d7e5251c4b34d5e6fc924a..dd1da5ab30a840b70b5420351882fb55520b175d 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -34,7 +34,13 @@ const char *c_dap_chain_datum_token_emission_type_str[]={
[DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH] = "AUTH",
[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",
+ [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[] = {
@@ -67,10 +73,12 @@ dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, size
}
switch( a_token->type){
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
l_tsd_size = a_token->header_private_decl.tsd_total_size;
break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
l_tsd_size = a_token->header_private_update.tsd_total_size;
break;
default: return NULL;
@@ -101,6 +109,56 @@ dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, size
}
}
+dap_chain_datum_token_t *dap_chain_datum_token_read(byte_t *a_token_serial, size_t *a_token_size) {
+
+ uint16_t l_token_type = ((dap_chain_datum_token_t *)a_token_serial)->type;
+ if ( dap_chain_datum_token_is_old(l_token_type) ) {
+ dap_chain_datum_token_old_t * l_token_old = DAP_NEW_Z_SIZE(dap_chain_datum_token_old_t, (*a_token_size));
+ memcpy(l_token_old, a_token_serial, (*a_token_size));
+ size_t l_token_size = (*a_token_size) - sizeof(*l_token_old) + sizeof(dap_chain_datum_token_t);
+ dap_chain_datum_token_t * l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, l_token_size);
+ strncpy(l_token->ticker, l_token_old->ticker, sizeof(l_token_old->ticker) );
+ size_t l_token_tsd_size = (*a_token_size) - sizeof(*l_token_old);
+ memcpy(l_token->data_n_tsd, l_token_old->data_n_tsd, l_token_tsd_size);
+
+ switch( l_token_type ){
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
+ l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
+ l_token->header_private.total_supply_256 = GET_256_FROM_64(l_token_old->header_private.total_supply);
+ l_token->header_private.signs_valid = l_token_old->header_private.signs_valid;
+ l_token->header_private.signs_total = l_token_old->header_private.signs_total;
+ break;
+ }
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
+ l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL; // 256
+ l_token->header_private_decl.flags = l_token_old->header_private_decl.flags;
+ l_token->header_private_decl.tsd_total_size = l_token_old->header_private_decl.tsd_total_size;
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE; // 256
+ l_token->header_private_update.padding = l_token_old->header_private_update.padding;
+ l_token->header_private_update.tsd_total_size = l_token_old->header_private_update.tsd_total_size;
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC:
+ l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC; // 256
+ l_token->header_public.total_supply_256 = GET_256_FROM_128(l_token_old->header_public.total_supply);
+ l_token->header_public.premine_supply_256 = GET_256_FROM_128(l_token_old->header_public.premine_supply);
+ memcpy(&l_token->header_public.premine_address, &l_token_old->header_public.premine_address, sizeof(l_token_old->header_public.premine_address));
+ break;
+ default:
+ DAP_DELETE(l_token_old);
+ return NULL;
+ }
+ DAP_DELETE(l_token_old);
+ return l_token;
+ } else {
+ dap_chain_datum_token_t * l_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, (*a_token_size));
+ memcpy(l_token, a_token_serial, (*a_token_size));
+ return l_token;
+ }
+ return NULL;
+}
+
/**
* @brief dap_chain_datum_token_flags_dump
* @param a_str_out
@@ -177,6 +235,7 @@ dap_sign_t ** dap_chain_datum_token_simple_signs_parse(dap_chain_datum_token_t *
*a_signs_valid = a_datum_token->header_private.signs_valid;
size_t l_offset = 0;
uint16_t n = 0;
+
while( l_offset < (a_datum_token_size-sizeof (a_datum_token) ) && n < a_datum_token->header_private.signs_total ) {
dap_sign_t *l_sign = (dap_sign_t *) ( a_datum_token->data_n_tsd + l_offset);
size_t l_sign_size = dap_sign_get_size(l_sign);
@@ -212,26 +271,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:
+ 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:
+ 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:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_UNDEFINED:
+ default:
+ break;
}
return l_ret;
}
@@ -247,13 +311,38 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emissi
size_t l_add_size = sizeof(l_emission->hdr) - l_old_hdr_size;
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_emission_size + l_add_size);
l_emission->hdr.version = 1;
+ // l_emission->hdr.type_256 = false;
memcpy(l_emission, a_emission_serial, l_old_hdr_size);
memcpy((byte_t *)l_emission + sizeof(l_emission->hdr),
a_emission_serial + l_old_hdr_size,
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;
}
+
+// #define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE 0x0001
+// Extended declaration of privatetoken with in-time control
+// #define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL 0x0002
+// Token update
+// #define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE 0x0003
+// Open token with now ownership
+// #define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC 0x0004
+
+// 256 TYPE
+bool dap_chain_datum_token_is_old(uint8_t a_type) {
+ switch(a_type) {
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC:
+ return true;
+ default:
+ return false;
+ }
+}
+
+
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 7c91336dfcea560008144827508c0f777504426c..7cb301e07ef4e52224811c88d729e213e4b10a9b 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 5648eb92cff4a4b2c54ff49e6c0865487e5f812d..59b64a3aeec1a30a13928e545a209f7de3d69820 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.h b/modules/common/include/dap_chain_datum.h
index 8723dda037d328b86487321e48b054934919786d..3ccaaf44e17095818053103ef450859feab6cbca 100644
--- a/modules/common/include/dap_chain_datum.h
+++ b/modules/common/include/dap_chain_datum.h
@@ -37,9 +37,7 @@
/// Transaction header section
#define DAP_CHAIN_DATUM_TX 0x0100
-
-// 256
-#define DAP_CHAIN_DATUM_256_TX 0x0101
+#define DAP_CHAIN_DATUM_256_TX 0x0101 // 256
/// Transaction request section
#define DAP_CHAIN_DATUM_TX_REQUEST 0x0300
@@ -61,6 +59,7 @@
/// Token
/// Simple token decl
#define DAP_CHAIN_DATUM_TOKEN_DECL 0xf000
+#define DAP_CHAIN_DATUM_256_TOKEN_DECL 0xf001 // 256
#define DAP_CHAIN_DATUM_TOKEN_EMISSION 0xf100
#define DAP_CHAIN_DATUM_256_TOKEN_EMISSION 0xf101 // 256
#define DAP_CHAIN_DATUM_TOKEN_DISMISSAL 0xf200
@@ -89,6 +88,8 @@
s = "DATUM_CUSTOM"; break; \
case DAP_CHAIN_DATUM_TOKEN_DECL: \
s = "DATUM_TOKEN_DECL"; break; \
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL: \
+ s = "DATUM_256_TOKEN_DECL"; break; \
case DAP_CHAIN_DATUM_TOKEN_EMISSION:\
s = "DATUM_TOKEN_EMISSION"; break;\
case DAP_CHAIN_DATUM_256_TOKEN_EMISSION:\
diff --git a/modules/common/include/dap_chain_datum_token.h b/modules/common/include/dap_chain_datum_token.h
index 20a75ba505103de2803f510f891aab6254136deb..53939e98082797f9f3514dd14a77aa359875a4b3 100644
--- a/modules/common/include/dap_chain_datum_token.h
+++ b/modules/common/include/dap_chain_datum_token.h
@@ -31,6 +31,36 @@
#include "dap_tsd.h"
#include "dap_strfuncs.h"
+
+// Token declaration
+typedef struct dap_chain_datum_token_old {
+ uint16_t type;
+ char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
+ union {
+ struct {
+ uint64_t total_supply;
+ uint16_t signs_valid;
+ uint16_t signs_total;
+ } DAP_ALIGN_PACKED header_private;
+ struct {
+ uint16_t flags;
+ size_t tsd_total_size;
+ } DAP_ALIGN_PACKED header_private_decl;
+ struct {
+ uint16_t padding;
+ size_t tsd_total_size;
+ } DAP_ALIGN_PACKED header_private_update;
+ struct {
+ uint128_t total_supply;
+ uint128_t premine_supply;
+ dap_chain_addr_t premine_address;
+ uint32_t flags;
+ } DAP_ALIGN_PACKED header_public;
+ };
+ byte_t data_n_tsd[];
+} DAP_ALIGN_PACKED dap_chain_datum_token_old_t;
+
+
// Token declaration
typedef struct dap_chain_datum_token{
uint16_t type;
@@ -38,7 +68,10 @@ typedef struct dap_chain_datum_token{
union {
// Simple private token declaration. Useful for 100% premined emission without any plays with token and owners after that
struct {
- uint64_t total_supply; // Could be zero if unlimited
+ union {
+ uint64_t total_supply; // Could be zero if unlimited
+ uint256_t total_supply_256;
+ };
uint16_t signs_valid; // Emission auth signs
uint16_t signs_total; // Emission auth signs
} DAP_ALIGN_PACKED header_private;
@@ -54,8 +87,14 @@ typedef struct dap_chain_datum_token{
} DAP_ALIGN_PACKED header_private_update;
// Public token declaration
struct {
- uint128_t total_supply;
- uint128_t premine_supply;
+ union {
+ uint128_t total_supply;
+ uint256_t total_supply_256;
+ };
+ union {
+ uint128_t premine_supply;
+ uint256_t premine_supply_256;
+ };
dap_chain_addr_t premine_address;
uint32_t flags;
} DAP_ALIGN_PACKED header_public;
@@ -65,13 +104,23 @@ typedef struct dap_chain_datum_token{
// Token declaration type
// Simple private token decl
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE 0x0001
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE 0x0001
// Extended declaration of privatetoken with in-time control
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL 0x0002
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL 0x0002
// Token update
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE 0x0003
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE 0x0003
// Open token with now ownership
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC 0x0004
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC 0x0004
+
+// 256
+// Simple private token decl
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE 0x0005
+// Extended declaration of privatetoken with in-time control
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL 0x0006
+// Token update
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE 0x0007
+// Open token with now ownership
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC 0x0008
// Macros for token flags
@@ -147,7 +196,8 @@ static inline uint16_t dap_chain_datum_token_flag_from_str(const char* a_str)
#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_UNSET_FLAGS 0x0002
// Total supply limits
-#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY 0x0003
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY 0x0003 // 128
+#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256 0x0026 // 256
// Set total signs count value to set to be valid
#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID 0x0004
@@ -210,7 +260,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 {
@@ -218,6 +267,7 @@ typedef struct dap_chain_datum_token_emission{
uint256_t value_256;
};
uint8_t nonce[DAP_CHAIN_DATUM_NONCE_SIZE];
+ // bool type_256; // emission 256
} DAP_ALIGN_PACKED hdr;
union {
struct {
@@ -248,14 +298,22 @@ 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_t *dap_chain_datum_token_read(byte_t *a_token_serial, size_t *a_token_size);
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_is_old(uint8_t a_type);
diff --git a/modules/common/include/dap_chain_datum_tx_items.h b/modules/common/include/dap_chain_datum_tx_items.h
index d5425f70b3085f4b5ef00f5f2bf99f8e65ff15ab..216577aaa75a3bc8307ab9bee6f91d8f10957888 100644
--- a/modules/common/include/dap_chain_datum_tx_items.h
+++ b/modules/common/include/dap_chain_datum_tx_items.h
@@ -59,7 +59,9 @@ DAP_STATIC_INLINE const char * dap_chain_datum_tx_item_type_to_str(dap_chain_tx_
case TX_ITEM_TYPE_PKEY: return "TX_ITEM_TYPE_PKEY";
case TX_ITEM_TYPE_SIG: return "TX_ITEM_TYPE_SIG";
case TX_ITEM_TYPE_TOKEN: return "TX_ITEM_TYPE_TOKEN";
+ case TX_ITEM_TYPE_256_TOKEN: return "TX_ITEM_TYPE_256_TOKEN"; // 256
case TX_ITEM_TYPE_TOKEN_EXT: return "TX_ITEM_TYPE_TOKEN_EXT";
+ case TX_ITEM_TYPE_256_TOKEN_EXT: return "TX_ITEM_TYPE_256_TOKEN_EXT"; // 256
case TX_ITEM_TYPE_IN_COND: return "TX_ITEM_TYPE_IN_COND";
case TX_ITEM_TYPE_OUT_COND: return "TX_ITEM_TYPE_OUT_COND";
case TX_ITEM_TYPE_256_OUT_COND: return "TX_ITEM_TYPE_256_OUT_COND"; // 256
@@ -107,7 +109,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 +119,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 +130,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 +142,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 +156,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 +189,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 37c18c0e5429e298f8404837594f431d65b24652..0394a74ef6ef244c51aec5852a61f34735d3790e 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 e90701767a1172caf75fb9fe86e62908519fa099..1bbd166f0a7f75bd9318382833e3d34733b56ba7 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 400a61f68f9285df84f449c2c592ff80dd769de9..1a310068cb2a0b20160e76798b1ccc214dd49662 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 823eb9cf4a62199378dc38e1b7e35f959e14f2d0..415910ef4d43c9b4cb2e4f153d464d3d13cec7c3 100644
--- a/modules/consensus/none/dap_chain_cs_none.c
+++ b/modules/consensus/none/dap_chain_cs_none.c
@@ -343,6 +343,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
return ATOM_REJECT;
}
switch (l_datum->header.type_id) {
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL: // 256
case DAP_CHAIN_DATUM_TOKEN_DECL:{
dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
if (dap_chain_ledger_token_load(a_chain->ledger,l_token, l_datum->header.data_size))
@@ -350,10 +351,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 72db2cd695485b871241849554b5d18c13e83a3a..ac3dbf15c4ef6ae3f5a052ae48b077c7fcdcb362 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -2548,16 +2548,17 @@ int dap_chain_net_verify_datum_for_add(dap_chain_net_t *a_net, dap_chain_datum_t
return dap_chain_ledger_tx_add_check( a_net->pub.ledger,
(dap_chain_datum_tx_t*) a_datum->data );
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL: // 256
case DAP_CHAIN_DATUM_TOKEN_DECL:
return dap_chain_ledger_token_decl_add_check( a_net->pub.ledger,
(dap_chain_datum_token_t*) a_datum->data );
case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) a_datum->data;
- l_token_em->hdr.type_value_256 = a_datum->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ?
- true : false;
- return dap_chain_ledger_token_emission_add_check( a_net->pub.ledger, 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;
}
@@ -2579,6 +2580,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
return;
}
switch (a_datum->header.type_id){
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL:
case DAP_CHAIN_DATUM_TOKEN_DECL:{
dap_chain_datum_token_t * l_token = (dap_chain_datum_token_t*) a_datum->data;
size_t l_token_size = a_datum->header.data_size;
@@ -2591,12 +2593,18 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_string_append_printf(a_str_out, "ticker: %s\n", l_token->ticker);
dap_string_append_printf(a_str_out, "size: %zd\n", l_token_size);
switch (l_token->type) {
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:{
dap_string_append_printf(a_str_out, "type: SIMPLE\n");
dap_string_append_printf(a_str_out, "sign_total: %hu\n", l_token->header_private.signs_total );
dap_string_append_printf(a_str_out, "sign_valid: %hu\n", l_token->header_private.signs_valid );
- dap_string_append_printf(a_str_out, "total_supply: %"DAP_UINT64_FORMAT_U"\n", l_token->header_private.total_supply );
+ if ( dap_chain_datum_token_is_old(l_token->type) )
+ dap_string_append_printf(a_str_out, "total_supply: %"DAP_UINT64_FORMAT_U"\n", l_token->header_private.total_supply );
+ else
+ dap_string_append_printf(a_str_out, "total_supply: %s\n",
+ dap_chain_u256tostr(l_token->header_private.total_supply_256));
}break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:{
dap_string_append_printf(a_str_out,"type: PRIVATE_UPDATE\n");
dap_tsd_t * l_tsd = dap_chain_datum_token_tsd_get(l_token, l_token_size);
@@ -2622,9 +2630,15 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
dap_chain_datum_token_flags_dump(a_str_out,
dap_tsd_get_scalar(l_tsd, uint16_t));
break;
- case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY:
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: // 256
+ dap_string_append_printf(a_str_out,"total_supply: %s\n",
+ dap_chain_u256tostr(
+ dap_tsd_get_scalar(l_tsd, uint256_t)));
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: // 128
dap_string_append_printf(a_str_out,"total_supply: %s\n",
- dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint128_t)));
+ dap_chain_balance_print(
+ dap_tsd_get_scalar(l_tsd, uint128_t)));
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID :
dap_string_append_printf(a_str_out,"total_signs_valid: %u\n",
@@ -2709,6 +2723,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
}
}
}break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:{
dap_string_append_printf(a_str_out,"type: PRIVATE_DECL\n");
dap_string_append_printf(a_str_out,"flags: ");
@@ -2727,9 +2742,15 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
return;
}
switch( l_tsd->type){
- case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY:
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: // 256
dap_string_append_printf(a_str_out,"total_supply: %s\n",
- dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint128_t)));
+ dap_chain_u256tostr(
+ dap_tsd_get_scalar(l_tsd, uint256_t)));
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: // 128
+ dap_string_append_printf(a_str_out,"total_supply: %s\n",
+ dap_chain_balance_print(
+ dap_tsd_get_scalar(l_tsd, uint128_t)));
break;
case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID :
dap_string_append_printf(a_str_out,"total_signs_valid: %u\n",
@@ -2769,6 +2790,7 @@ void dap_chain_net_dump_datum(dap_string_t * a_str_out, dap_chain_datum_t * a_da
size_t l_certs_field_size = l_token_size - sizeof(*l_token) - l_token->header_private_decl.tsd_total_size;
dap_chain_datum_token_certs_dump(a_str_out, l_token->data_n_tsd, l_certs_field_size);
}break;
+ case DAP_CHAIN_DATUM_256_TX:
case DAP_CHAIN_DATUM_TX:{
dap_chain_datum_tx_t * l_tx =(dap_chain_datum_tx_t *) a_datum->data;
char buf[50];
@@ -2794,27 +2816,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
+ // 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_256_OUT_EXT: // 256
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:{
@@ -2859,13 +2894,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");
@@ -2879,11 +2945,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 0ca0fb95cd7a2d6169450e685a9932fcd1ca8669..75e348ad4ef6424351e4790cf25de256a8574429 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -1798,6 +1798,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
dap_string_append_printf(l_string_ret, "balance:\n");
else
dap_string_append_printf(l_string_ret, "balance: 0");
+
for(size_t i = 0; i < l_addr_tokens_size; i++) {
if(l_addr_tokens[i]) {
// uint128_t l_balance = dap_chain_ledger_calc_balance(l_ledger, l_addr, l_addr_tokens[i]);
@@ -2457,7 +2458,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
int l_arg_index = 1;
const char * l_type_str = NULL;
- uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
+ uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
const char * l_ticker = NULL;
@@ -2492,7 +2493,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
l_arg_index=dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-type", &l_type_str);
if (!l_type_str || !strcmp(l_type_str, "private")) {
- l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE;
+ l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE; // 256
} else {
dap_chain_node_cli_set_reply_text(a_str_reply, "token_update can't accept type \"%s\"", l_type_str);
return -22;
@@ -2502,7 +2503,8 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
size_t l_datum_data_offset = 0;
switch(l_type){
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:{
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:{ // 256
dap_list_t *l_tsd_list = dap_list_alloc();
size_t l_tsd_total_size = 0;
l_arg_index++;
@@ -2523,7 +2525,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
}
// Add flags as set_flags TDS section
dap_tsd_t * l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_SET_FLAGS, l_flags);
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_SET_FLAGS, l_flags);
dap_list_append( l_tsd_list, l_tsd);
l_tsd_total_size+= dap_tsd_size( l_tsd);
@@ -2554,9 +2556,16 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
return -10;
}
} else if ( strcmp( a_argv[l_arg_index],"-total_supply" )==0){ // Total supply
- uint128_t l_param_value = dap_chain_balance_scan(l_arg_param);
- dap_tsd_t * l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY, l_param_value);
+ dap_tsd_t * l_tsd;
+ if ( dap_chain_datum_token_is_old(l_type) ) { // 128
+ uint128_t l_param_value = dap_chain_balance_scan(l_arg_param);
+ l_tsd = dap_tsd_create_scalar(
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY, l_param_value);
+ } else { // 256
+ uint256_t l_param_value = GET_256_FROM_128(dap_chain_balance_scan(l_arg_param));
+ l_tsd = dap_tsd_create_scalar(
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256, l_param_value);
+ }
dap_list_append( l_tsd_list, l_tsd);
l_tsd_total_size+= dap_tsd_size( l_tsd);
}else if ( strcmp( a_argv[l_arg_index],"-total_signs_valid" )==0){ // Signs valid
@@ -2645,7 +2654,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
// Create new datum token
l_datum_token_update = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t)+l_tsd_total_size ) ;
- l_datum_token_update->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE;
+ l_datum_token_update->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE; // 256
dap_snprintf(l_datum_token_update->ticker, sizeof(l_datum_token_update->ticker), "%s", l_ticker);
l_datum_token_update->header_private_update.tsd_total_size = l_tsd_total_size;
@@ -2773,12 +2782,11 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
int l_arg_index = 1;
const char * l_type_str = NULL;
- uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
const char * l_ticker = NULL;
const char * l_total_supply_str = NULL;
- uint64_t l_total_supply = 0;
+ uint256_t l_total_supply = uint256_0; // 256
const char * l_signs_emission_str = NULL;
uint16_t l_signs_emission = 0;
@@ -2794,6 +2802,13 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_t * l_chain = NULL;
dap_chain_net_t * l_net = NULL;
+ // 256
+ bool l_type_256 = true; //dap_chain_node_cli_check_option(a_argv, l_arg_index, a_argc, "-256") == -1 ? false : true;
+
+ uint16_t l_type = l_type_256
+ ? DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE // 256
+ : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE;
+
const char * l_hash_out_type = NULL;
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
@@ -2825,11 +2840,14 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
if (l_type_str) {
if (strcmp( l_type_str, "private") == 0){
- l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL;
+ l_type = l_type_256 ? DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL // 256
+ : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL;
}else if (strcmp( l_type_str, "private_simple") == 0){
- l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
+ l_type = l_type_256 ? DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE // 256
+ : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE;
}else if (strcmp( l_type_str, "public_simple") == 0){
- l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC;
+ l_type = l_type_256 ? DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC // 256
+ : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC;
}
}
@@ -2837,7 +2855,8 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
size_t l_datum_data_offset = 0;
switch(l_type){
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:{
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL: {
dap_list_t *l_tsd_list = dap_list_alloc();
size_t l_tsd_total_size = 0;
uint16_t l_flags = 0;
@@ -2857,9 +2876,16 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
l_str_flags++;
}
} else if ( strcmp( a_argv[l_arg_index],"-total_supply" )==0){ // Total supply
- uint128_t l_param_value = dap_chain_balance_scan(l_arg_param);
- dap_tsd_t * l_tsd = dap_tsd_create_scalar(
- DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY, l_param_value);
+ dap_tsd_t * l_tsd;
+ if ( l_type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL ) { // 256
+ uint256_t l_param_value = GET_256_FROM_128(dap_chain_balance_scan(l_arg_param));
+ l_tsd = dap_tsd_create_scalar(
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256, l_param_value);
+ } else { // 128
+ uint128_t l_param_value = dap_chain_balance_scan(l_arg_param);
+ l_tsd = dap_tsd_create_scalar(
+ DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY, l_param_value);
+ }
dap_list_append( l_tsd_list, l_tsd);
l_tsd_total_size+= dap_tsd_size( l_tsd);
}else if ( strcmp( a_argv[l_arg_index],"-total_signs_valid" )==0){ // Signs valid
@@ -2921,7 +2947,9 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
log_it(L_DEBUG,"Prepeared TSD sections on %zd total size", l_tsd_total_size);
// Create new datum token
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t)+l_tsd_total_size ) ;
- l_datum_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL;
+
+ l_datum_token->type = l_type; //DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL;
+
dap_snprintf(l_datum_token->ticker, sizeof(l_datum_token->ticker), "%s", l_ticker);
l_datum_token->header_private_decl.flags = l_flags;
log_it(L_DEBUG,"Token declaration '%s' initialized", l_datum_token->ticker);
@@ -2949,8 +2977,16 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
continue;
}
switch (l_tsd->type){
- case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: {
- char *l_balance = dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint128_t));
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: { // 256
+ char *l_balance;
+ l_balance = dap_chain_u256tostr(dap_tsd_get_scalar(l_tsd, uint256_t));
+ log_it(L_DEBUG,"== TOTAL_SUPPLY: %s", l_balance);
+ DAP_DELETE(l_balance);
+ }
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: { // 128
+ char *l_balance;
+ l_balance = dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint128_t));
log_it(L_DEBUG,"== TOTAL_SUPPLY: %s", l_balance);
DAP_DELETE(l_balance);
}
@@ -2989,7 +3025,8 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
}break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:{
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
// Total supply value
dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-total_supply", &l_total_supply_str);
@@ -3008,8 +3045,10 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-total_supply'");
return -3;
} else {
- char * l_tmp = NULL;
- if((l_total_supply = strtoull(l_total_supply_str, &l_tmp, 10)) == 0) {
+ // char * l_tmp = NULL;
+ l_total_supply = GET_256_FROM_128(dap_chain_balance_scan(l_total_supply_str));
+ //if((l_total_supply = strtoull(l_total_supply_str, &l_tmp, 10)) == 0) {
+ if ( IS_ZERO_256(l_total_supply) ) {
dap_chain_node_cli_set_reply_text(a_str_reply,
"token_create requires parameter '-total_supply' to be unsigned integer value that fits in 8 bytes");
return -4;
@@ -3064,9 +3103,14 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// Create new datum token
l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t));
- l_datum_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
+ l_datum_token->type = l_type_256
+ ? DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE // 256
+ : DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE;
dap_snprintf(l_datum_token->ticker, sizeof(l_datum_token->ticker), "%s", l_ticker);
- l_datum_token->header_private.total_supply = l_total_supply;
+ if ( l_type_256 )
+ l_datum_token->header_private.total_supply_256 = l_total_supply;
+ else
+ l_datum_token->header_private.total_supply = dap_chain_uint256_to(l_total_supply);
l_datum_token->header_private.signs_total = l_signs_total;
l_datum_token->header_private.signs_valid = l_signs_emission;
@@ -3090,8 +3134,13 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
return -8;
}
- dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_DECL, l_datum_token,
- sizeof(*l_datum_token) + l_datum_data_offset);
+ dap_chain_datum_t * l_datum = l_type_256
+ ? dap_chain_datum_create( // 256
+ DAP_CHAIN_DATUM_256_TOKEN_DECL,
+ l_datum_token, sizeof(*l_datum_token) + l_datum_data_offset)
+ : dap_chain_datum_create(
+ DAP_CHAIN_DATUM_TOKEN_DECL,
+ l_datum_token, sizeof(*l_datum_token) + l_datum_data_offset);
size_t l_datum_size = dap_chain_datum_size(l_datum);
// Calc datum's hash
@@ -3110,14 +3159,15 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
}
int l_ret = 0;
+ char * l_datum_type = l_type_256 ? "256_t" : "";
if(dap_chain_global_db_gr_set(dap_strdup(l_key_str), (uint8_t *) l_datum, l_datum_size, l_gdb_group_mempool)) {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s with token %s is placed in datum pool ", l_key_str, l_ticker);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s %s with token %s is placed in datum pool ", l_datum_type, l_key_str, l_ticker);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s with token %s is placed in datum pool ", l_key_str_base58, l_ticker);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s %s with token %s is placed in datum pool ", l_datum_type, l_key_str_base58, l_ticker);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum tx %s is not placed in datum pool ", l_key_str_base58);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "datum tx %s %s is not placed in datum pool ", l_datum_type, l_key_str_base58);
DAP_DELETE(l_datum);
l_ret = -2;
}
@@ -3146,7 +3196,7 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
const char * l_addr_str = NULL;
const char * l_emission_hash_str = NULL;
- const char * l_type_256 = NULL;
+ bool l_type_256 = true; // false;
char * l_emission_hash_str_new = NULL;
dap_chain_hash_fast_t l_emission_hash={0};
@@ -3190,7 +3240,8 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission", &l_emission_hash_str);
// 256
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-256", &l_type_256);
+ // dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-256", &l_type_256);
+ //l_type_256 = dap_chain_node_cli_check_option(a_argv, arg_index, a_argc, "-256") == -1 ? false : true;
// Emission certs
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
@@ -3308,17 +3359,20 @@ 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_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_256 = true;
l_emission->hdr.value_256 = l_emission_value;
}
+ l_emission->hdr.type = DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH;
l_emission->hdr.version = 1;
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);
@@ -3371,15 +3425,23 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
if(dap_chain_global_db_gr_set(dap_strdup(l_emission_hash_str_new), (uint8_t *) l_datum_emission, l_datum_emission_size
, l_gdb_group_mempool_emission)) {
if(!dap_strcmp(l_hash_out_type,"hex"))
- str_reply_tmp = dap_strdup_printf("Datum emission %s is placed in datum pool", l_emission_hash_str_new);
+ str_reply_tmp = dap_strdup_printf("Datum%s emission %s is placed in datum pool",
+ (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
+ l_emission_hash_str_new);
else
- str_reply_tmp = dap_strdup_printf("Datum emission %s is placed in datum pool", l_emission_hash_str_base58);
+ str_reply_tmp = dap_strdup_printf("Datum%s emission %s is placed in datum pool",
+ (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
+ l_emission_hash_str_base58);
}
else {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum emission %s is not placed in datum pool", l_emission_hash_str_new);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Datum%s emission %s is not placed in datum pool",
+ (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
+ l_emission_hash_str_new);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum emission %s is not placed in datum pool", l_emission_hash_str_base58);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Datum%s emission %s is not placed in datum pool",
+ (l_datum_emission->header.type_id == DAP_CHAIN_DATUM_256_TOKEN_EMISSION ? " 256_t" : ""),
+ l_emission_hash_str_base58);
DAP_DEL_Z(l_emission_hash_str_new);
l_emission_hash_str = NULL;
DAP_DEL_Z(l_emission_hash_str_base58);
@@ -3466,16 +3528,28 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
if(dap_chain_global_db_gr_set(dap_strdup(l_tx_hash_str), l_datum_tx, l_datum_tx_size
, l_gdb_group_mempool_base_tx)) {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum tx %s is placed in datum pool ", str_reply_tmp, l_tx_hash_str);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is placed in datum pool ",
+ str_reply_tmp,
+ (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
+ l_tx_hash_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum tx %s is placed in datum pool ", str_reply_tmp, l_tx_hash_str_base58);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is placed in datum pool ",
+ str_reply_tmp,
+ (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
+ l_tx_hash_str_base58);
DAP_DEL_Z(l_tx_hash_str);
DAP_DEL_Z(l_tx_hash_str_base58);
} else {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum tx %s is not placed in datum pool ", str_reply_tmp, l_emission_hash_str);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is not placed in datum pool ",
+ str_reply_tmp,
+ (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
+ l_emission_hash_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum tx %s is not placed in datum pool ", str_reply_tmp, l_tx_hash_str_base58);
+ dap_chain_node_cli_set_reply_text(a_str_reply, "%s\ndatum%s tx %s is not placed in datum pool ",
+ str_reply_tmp,
+ (l_datum_tx->header.type_id == DAP_CHAIN_DATUM_256_TX ? " 256_t" : ""),
+ l_tx_hash_str_base58);
DAP_DEL_Z(l_tx_hash_str);
DAP_DEL_Z(l_tx_hash_str_base58);
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index bd5d2b66ac00eef7c4256fd55eb725c046967e1d..7fb56397a1f65f2911732a3eb67ff22b72b94d63 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -167,10 +167,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:
@@ -374,27 +374,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;
@@ -402,11 +402,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:
@@ -414,15 +414,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;
}
@@ -445,12 +445,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:
@@ -553,24 +553,24 @@ 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);
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));
//l_tx_data->pos_num = l_count;
@@ -582,7 +582,6 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
dap_chain_tx_token_t *tk = l_list_tx_token->data;
memcpy(l_tx_data->token_ticker, tk->header.ticker, sizeof(l_tx_data->token_ticker));
}
- // take token from prev out item
else {
// find IN items
@@ -616,6 +615,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
}
l_list_tmp = dap_list_next(l_list_tmp);
}
+
if(l_list_out_items)
dap_list_free(l_list_out_items);
@@ -644,21 +644,22 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
else
l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
l_list_tmp = l_list_out_items;
+
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 : "?"
);
@@ -672,6 +673,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
DAP_DELETE(l_dst_to_str);
l_list_tmp = dap_list_next(l_list_tmp);
}
+
// find all IN items in transaction
dap_list_t *l_list_in_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_IN, NULL);
l_list_tmp = l_list_in_items;
@@ -684,6 +686,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
if(!dap_hash_fast_is_blank(&tx_prev_hash)){
tx_hash_base58_str = dap_enc_base58_from_hex_str_to_str( l_tx_data->tx_hash_str);
dap_chain_hash_fast_to_str(&tx_prev_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
+
}
else{
strcpy(l_tx_hash_str, "Null");
@@ -695,6 +698,7 @@ char* dap_db_history_tx(dap_chain_hash_fast_t* a_tx_hash, dap_chain_t * a_chain,
dap_string_append_printf(l_str_out, " IN item \n prev tx_hash %s\n", tx_hash_base58_str);
DAP_DELETE(tx_hash_base58_str);
+
//find prev OUT item
dap_tx_data_t *l_tx_data_prev = NULL;
HASH_FIND(hh, l_tx_data_hash, &tx_prev_hash, sizeof(dap_chain_hash_fast_t), l_tx_data_prev);
@@ -711,22 +715,21 @@ 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);
+ l_tx_prev_out ? l_tx_prev_out->header.value : 0);
+
}
}
dap_string_append_printf(l_str_out, "\n");
@@ -1211,40 +1214,60 @@ static char* dap_db_history_token_list(dap_chain_t * a_chain, const char *a_toke
dap_string_append(l_str_out, "\n");
dap_string_append_printf(l_str_out, "token %s, created: %s\n", l_token->ticker, l_time_str);
switch (l_token->type) {
- // Simple private token decl
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:
- dap_string_append_printf(l_str_out, " total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
- dap_chain_datoshi_to_coins(l_token->header_private.total_supply),
- l_token->header_private.total_supply,
- l_token->header_private.signs_valid, l_token->header_private.signs_total);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
- dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
- l_token->header_private_decl.tsd_total_size,
- l_token->header_private_decl.flags);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
- dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
- l_token->header_private_update.tsd_total_size,
- l_token->header_private_update.padding);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: {
- char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
- char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
- dap_string_append_printf(l_str_out,
- " total_supply: %.0Lf(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
- dap_chain_datoshi_to_coins(l_token->header_public.total_supply),
- dap_chain_balance_print(l_token->header_public.total_supply),
- l_token->header_public.flags,
- dap_chain_balance_print(l_token->header_public.premine_supply),
- l_addr ? l_addr : "-");
- DAP_DELETE(l_addr);
- DAP_DELETE(l_balance);
- }
- break;
- default:
- dap_string_append_printf(l_str_out, "unknown token type: 0x%x\n", l_token->type);
- break;
+ // Simple private token decl
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
+ dap_string_append_printf(l_str_out, " total_supply: %s(%s), signs: valid/total %02d/%02d \n",
+ dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_private.total_supply_256)),
+ dap_chain_u256tostr(l_token->header_private.total_supply_256),
+ l_token->header_private.signs_valid, l_token->header_private.signs_total);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
+ dap_string_append_printf(l_str_out, " total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
+ dap_chain_datoshi_to_coins(l_token->header_private.total_supply),
+ l_token->header_private.total_supply,
+ l_token->header_private.signs_valid, l_token->header_private.signs_total);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+ l_token->header_private_decl.tsd_total_size,
+ l_token->header_private_decl.flags);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
+ l_token->header_private_update.tsd_total_size,
+ l_token->header_private_update.padding);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: { // 256
+ char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
+ char * l_balance = dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_public.total_supply_256));
+ dap_string_append_printf(l_str_out,
+ " total_supply: %s(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
+ dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_public.total_supply_256)),
+ dap_chain_u256tostr(l_token->header_public.total_supply_256),
+ l_token->header_public.flags,
+ dap_chain_u256tostr(l_token->header_public.premine_supply_256),
+ l_addr ? l_addr : "-");
+ DAP_DELETE(l_addr);
+ DAP_DELETE(l_balance);
+ }break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC: {
+ char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
+ char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
+ dap_string_append_printf(l_str_out,
+ " total_supply: %.0Lf(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
+ dap_chain_datoshi_to_coins(l_token->header_public.total_supply),
+ dap_chain_balance_print(l_token->header_public.total_supply),
+ l_token->header_public.flags,
+ dap_chain_balance_print(l_token->header_public.premine_supply),
+ l_addr ? l_addr : "-");
+ DAP_DELETE(l_addr);
+ DAP_DELETE(l_balance);
+ }break;
+ default:
+ dap_string_append_printf(l_str_out, "unknown token type: 0x%x\n", l_token->type);
+ break;
}
dap_string_append_printf(l_str_out, "\n");
(*a_token_num)++;
@@ -1305,7 +1328,6 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
//l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
continue;
}
-
/*dap_chain_atom_iter_t *l_atom_iter = a_chain->callback_atom_iter_create(a_chain);
dap_chain_atom_ptr_t l_atom = a_chain->callback_atom_iter_get_first(l_atom_iter);
size_t l_atom_size = a_chain->callback_atom_get_size(l_atom);
@@ -1327,175 +1349,205 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
l_time_str[0] = '\0';
switch (l_datum->header.type_id) {
- // token
- case DAP_CHAIN_DATUM_TOKEN_DECL: {
- // no token necessary for addr
- if(a_filtr_addr_base58) {
- break;
- }
+ // token
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL: // 256
+ case DAP_CHAIN_DATUM_TOKEN_DECL: {
+ // no token necessary for addr
+ if(a_filtr_addr_base58) {
+ break;
+ }
- dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
- //if(a_datum_start < 0 || (l_datum_num >= a_datum_start && l_datum_num < a_datum_end))
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)){
- l_token_num++;
- break;
- }
- if(!a_filter_token_name || !dap_strcmp(l_token->ticker, a_filter_token_name)) {
- dap_string_append_printf(l_str_out, "token %s, created: %s\n", l_token->ticker, l_time_str);
- switch (l_token->type) {
- // Simple private token decl
- case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:
- dap_string_append_printf(l_str_out, " total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
- dap_chain_datoshi_to_coins(l_token->header_private.total_supply),
- l_token->header_private.total_supply,
- l_token->header_private.signs_valid, l_token->header_private.signs_total);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
- dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
- l_token->header_private_decl.tsd_total_size,
- l_token->header_private_decl.flags);
+ dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
+ //if(a_datum_start < 0 || (l_datum_num >= a_datum_start && l_datum_num < a_datum_end))
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)){
+ l_token_num++;
break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:
- dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
- l_token->header_private_update.tsd_total_size,
- l_token->header_private_update.padding);
- break;
- case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: {
- char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
- char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
- dap_string_append_printf(l_str_out,
- " total_supply: %.0Lf(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
- dap_chain_datoshi_to_coins(l_token->header_public.total_supply),
- dap_chain_balance_print(l_token->header_public.total_supply),
- l_token->header_public.flags,
- dap_chain_balance_print(l_token->header_public.premine_supply),
- l_addr ? l_addr : "-");
- DAP_DELETE(l_addr);
- DAP_DELETE(l_balance);
}
- break;
- default:
- dap_string_append_printf(l_str_out, "unknown token type: 0x%x\n", l_token->type);
- break;
+ if(!a_filter_token_name || !dap_strcmp(l_token->ticker, a_filter_token_name)) {
+ dap_string_append_printf(l_str_out, "token %s, created: %s\n", l_token->ticker, l_time_str);
+ switch (l_token->type) {
+ // Simple private token decl
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
+ dap_string_append_printf(l_str_out, " 256_t total_supply: %s(%s), signs: valid/total %02d/%02d \n",
+ dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_private.total_supply_256)),
+ dap_chain_u256tostr(l_token->header_private.total_supply_256),
+ l_token->header_private.signs_valid, l_token->header_private.signs_total);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
+ dap_string_append_printf(l_str_out, " total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
+ dap_chain_datoshi_to_coins(l_token->header_private.total_supply),
+ l_token->header_private.total_supply,
+ l_token->header_private.signs_valid, l_token->header_private.signs_total);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
+ dap_string_append_printf(l_str_out, "256_t tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+ l_token->header_private_decl.tsd_total_size,
+ l_token->header_private_decl.flags);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+ l_token->header_private_decl.tsd_total_size,
+ l_token->header_private_decl.flags);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
+ dap_string_append_printf(l_str_out, "256_t tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
+ l_token->header_private_update.tsd_total_size,
+ l_token->header_private_update.padding);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
+ dap_string_append_printf(l_str_out, " tsd_total_size: %"DAP_UINT64_FORMAT_U", padding: 0x%x \n",
+ l_token->header_private_update.tsd_total_size,
+ l_token->header_private_update.padding);
+ break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: { // 256
+ char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
+ char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
+ dap_string_append_printf(l_str_out,
+ " total_supply: %s(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
+ dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token->header_public.total_supply_256)),
+ dap_chain_u256tostr(l_token->header_public.total_supply_256),
+ l_token->header_public.flags,
+ dap_chain_u256tostr(l_token->header_public.premine_supply_256),
+ l_addr ? l_addr : "-");
+ DAP_DELETE(l_addr);
+ DAP_DELETE(l_balance);
+ } break;
+ case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC: {
+ char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
+ char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply);
+ dap_string_append_printf(l_str_out,
+ " total_supply: %.0Lf(%s), flags: 0x%x\n, premine_supply: %s, premine_address '%s'\n",
+ dap_chain_datoshi_to_coins(l_token->header_public.total_supply),
+ dap_chain_balance_print(l_token->header_public.total_supply),
+ l_token->header_public.flags,
+ dap_chain_balance_print(l_token->header_public.premine_supply),
+ l_addr ? l_addr : "-");
+ DAP_DELETE(l_addr);
+ DAP_DELETE(l_balance);
+ } break;
+ default:
+ dap_string_append_printf(l_str_out, "unknown token type: 0x%x\n", l_token->type);
+ break;
+ }
+ dap_string_append_printf(l_str_out, "\n");
+ l_token_num++;
}
- dap_string_append_printf(l_str_out, "\n");
- l_token_num++;
}
- }
- break;
+ break;
- // emission
- case DAP_CHAIN_DATUM_256_TOKEN_EMISSION:
- case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
- l_token_num++;
- break;
- }
- size_t l_emission_size = dap_chain_datum_emission_get_size(l_datum->data);
- dap_chain_datum_token_emission_t *l_token_em = dap_chain_datum_emission_read(l_datum->data, &l_emission_size);
- if(!a_filter_token_name || !dap_strcmp(l_token_em->hdr.ticker, a_filter_token_name)) {
- char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_em->hdr.address));
- // filter for addr
- if(dap_strcmp(a_filtr_addr_base58,l_token_emission_address_str)) {
+ // emission
+ case DAP_CHAIN_DATUM_256_TOKEN_EMISSION: // 256
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
+ l_token_num++;
break;
}
-
- if ( l_token_em->hdr.type_value_256 ) { // 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),
- l_token_em->hdr.ticker,
- c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
- l_token_em->hdr.version);
- } else
- dap_string_append_printf(l_str_out, "emission: %.0Lf(%"DAP_UINT64_FORMAT_U") %s, type: %s, version: %d\n",
- dap_chain_datoshi_to_coins(l_token_em->hdr.value),
- l_token_em->hdr.value,
- l_token_em->hdr.ticker,
- c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
- l_token_em->hdr.version);
-
- dap_string_append_printf(l_str_out, " to addr: %s\n", l_token_emission_address_str);
-
- 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);
- 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
- );
+ size_t l_emission_size = dap_chain_datum_emission_get_size(l_datum->data);
+ dap_chain_datum_token_emission_t *l_token_em = dap_chain_datum_emission_read(l_datum->data, &l_emission_size);
+ if(!a_filter_token_name || !dap_strcmp(l_token_em->hdr.ticker, a_filter_token_name)) {
+ char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_em->hdr.address));
+ // filter for addr
+ if(dap_strcmp(a_filtr_addr_base58,l_token_emission_address_str)) {
+ break;
}
- 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);
+ if ( l_token_em->hdr.version == 1 ) { // && l_token_em->hdr.type_256 ) { // 256
+ dap_string_append_printf(l_str_out, "emission 256: %s(%s) %s, type: %s, version: %d\n",
+ dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token_em->hdr.value_256)),
+ dap_chain_u256tostr(l_token_em->hdr.value_256),
+ l_token_em->hdr.ticker,
+ c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
+ l_token_em->hdr.version);
+ } else
+ dap_string_append_printf(l_str_out, "emission: %.0Lf(%"DAP_UINT64_FORMAT_U") %s, type: %s, version: %d\n",
+ dap_chain_datoshi_to_coins(l_token_em->hdr.value),
+ l_token_em->hdr.value,
+ l_token_em->hdr.ticker,
+ c_dap_chain_datum_token_emission_type_str[l_token_em->hdr.type],
+ l_token_em->hdr.version);
+ dap_string_append_printf(l_str_out, " to addr: %s\n", l_token_emission_address_str);
+
+ DAP_DELETE(l_token_emission_address_str);
+ switch (l_token_em->hdr.type) {
+ // case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_UNDEFINED: // 256
+ 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 ( l_token_em->hdr.version == 1 ) { // && l_token_em->hdr.type_256 ) { // 256
+ dap_string_append_printf(l_str_out, " value_start: %s(%s), codename: %s\n",
+ dap_chain_balance_to_coins(dap_chain_uint128_from_uint256(l_token_em->data.type_atom_owner.value_start_256)),
+ dap_chain_u256tostr(l_token_em->data.type_atom_owner.value_start_256),
+ l_token_em->data.type_atom_owner.value_change_algo_codename
+ );
+ } else {
+ dap_string_append_printf(l_str_out, " value_start: %.0Lf(%"DAP_UINT64_FORMAT_U"), codename: %s\n",
+ dap_chain_datoshi_to_coins(l_token_em->data.type_atom_owner.value_start),
+ l_token_em->data.type_atom_owner.value_start,
+ l_token_em->data.type_atom_owner.value_change_algo_codename
+ );
+ }
+ break;
+ // case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_256_SMART_CONTRACT:
+ case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_SMART_CONTRACT: {
+ char *l_addr = dap_chain_addr_to_str(&l_token_em->data.type_presale.addr);
+ // get time of create datum
+ 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");
+ l_emission_num++;
}
+ DAP_DELETE(l_token_em);
+ } break;
+
+ // transaction
+ case DAP_CHAIN_DATUM_TX:{
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
+ l_tx_num++;
break;
}
- dap_string_append_printf(l_str_out, "\n");
- l_emission_num++;
- }
- DAP_DELETE(l_token_em);
- } break;
-
- // transaction
- case DAP_CHAIN_DATUM_TX:{
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
- l_tx_num++;
- break;
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
+ //calc tx hash
+ s_dap_chain_datum_tx_out_data(l_tx, a_ledger, l_str_out, a_hash_out_type, true, &a_tx_hash_processed, &l_tx_num);
}
+ break;
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
- //calc tx hash
- s_dap_chain_datum_tx_out_data(l_tx, a_ledger, l_str_out, a_hash_out_type, true, &a_tx_hash_processed, &l_tx_num);
- }
- break;
-
- // transaction
- case DAP_CHAIN_DATUM_256_TX:{
+ // transaction
+ case DAP_CHAIN_DATUM_256_TX:{ // 256
+ // datum out of page
+ if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
+ l_tx_num++;
+ break;
+ }
+ dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
+ s_dap_chain_datum_tx_out_data(l_tx, a_ledger, l_str_out, a_hash_out_type, true, &a_tx_hash_processed, &l_tx_num);
+ }
+ break;
- // datum out of page
- if(a_datum_start >= 0 && (l_datum_num+l_datum_num_global < (size_t)a_datum_start || l_datum_num+l_datum_num_global >= (size_t)a_datum_end)) {
- l_tx_num++;
+ default:
+ dap_string_append_printf(l_str_out, "unknown datum type=%d\n", l_datum->header.type_id);
break;
}
- dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
- s_dap_chain_datum_tx_out_data(l_tx, a_ledger, l_str_out, a_hash_out_type, true, &a_tx_hash_processed, &l_tx_num);
- }
- break;
-
- default:
- dap_string_append_printf(l_str_out, "unknown datum type=%d\n", l_datum->header.type_id);
- break;
+ l_datum_num++;
}
- l_datum_num++;
- }
// go to next transaction
l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter, &l_atom_size);
//l_atom = a_chain->callback_atom_iter_get_next(l_atom_iter);
@@ -1584,7 +1636,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-all' or '-addr' or '-w'");
return -1;
}
-
// Select chain network
if(!l_net_str) {
dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-net'");
@@ -1596,7 +1647,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
return -3;
}
}
-
//Select chain emission
if(!l_chain_str) { // chain may be null -> then all chain use
//dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-chain'");
@@ -1611,7 +1661,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
}
//char *l_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
//const char *l_chain_group = dap_chain_gdb_get_group(l_chain);
-
dap_chain_hash_fast_t l_tx_hash;
if(l_tx_hash_str) {
if(dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash) < 0) {
@@ -1623,7 +1672,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
// dap_chain_hash_fast_to_str(&l_tx_hash, hash_str,99);
// int gsdgsd=523;
}
-
dap_chain_addr_t *l_addr = NULL;
// if need addr
if(l_wallet_name || l_addr_base58) {
@@ -1646,7 +1694,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
return -1;
}
}
-
dap_string_t *l_str_ret = dap_string_new(NULL); //char *l_str_ret = NULL;
dap_chain_t *l_chain_cur;
void *l_chain_tmp = (void*)0x1;
@@ -1657,7 +1704,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
// all chain
else
l_chain_cur = dap_chain_enum(&l_chain_tmp);
-
while(l_chain_cur) {
// only selected net
@@ -1669,18 +1715,15 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
char *l_str_out = NULL;
dap_string_append_printf(l_str_ret, "chain: %s\n", l_chain_cur->name);
dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name(l_net_str);
-
if(l_is_all) {
// without filters
l_str_out = dap_db_history_filter(l_chain_cur, l_ledger, NULL, NULL, l_hash_out_type, -1, 0, NULL, l_list_tx_hash_processd);
dap_string_append_printf(l_str_ret, "all history:\n%s\n", l_str_out ? l_str_out : " empty");
}
else {
-
l_str_out = l_tx_hash_str ?
dap_db_history_tx(&l_tx_hash, l_chain_cur, l_hash_out_type) :
dap_db_history_addr(l_addr, l_chain_cur, l_hash_out_type);
-
if(l_tx_hash_str) {
dap_string_append_printf(l_str_ret, "history for tx hash %s:\n%s\n", l_tx_hash_str,
l_str_out ? l_str_out : " empty");
@@ -1701,8 +1744,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_enum_unlock();
l_chain_cur = dap_chain_enum(&l_chain_tmp);
}
-
-
DAP_DELETE(l_addr);
_dap_chain_tx_hash_processed_ht_free(l_list_tx_hash_processd);
// all chain
@@ -1713,7 +1754,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
return 0;
}
else if(l_cmd == CMD_LIST){
-
enum {SUBCMD_NONE, SUBCMD_LIST_COIN};
int l_sub_cmd = SUBCMD_NONE;
if (dap_chain_node_cli_find_option_val(a_argv, 2, 3, "coins", NULL ))
@@ -1739,7 +1779,6 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_string_free(l_str_ret, true);
return 0;
} else if (l_cmd == CMD_TX_INFO){
-
//GET hash
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-hash", &l_tx_hash_str);
//get net
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index c119e6afa77981893bb13036830f76634bb8a3b6..192b6211fb370cc1a792388ab7737ae8903068ed 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -624,16 +624,17 @@ static int s_add_atom_to_ledger(dap_chain_cs_blocks_t * a_blocks, dap_ledger_t
for(size_t i=0; i<a_block_cache->datum_count; i++){
dap_chain_datum_t *l_datum = a_block_cache->datum[i];
switch (l_datum->header.type_id) {
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL:
case DAP_CHAIN_DATUM_TOKEN_DECL: {
dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
l_ret=dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
} 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 15640be1d5286e7a0fb538a503b2013051c5b529..c9b8a95cbe473211080b0d48e85cb415eda38ac2 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -291,6 +291,7 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
dap_chain_datum_t *l_datum = (dap_chain_datum_t*) dap_chain_cs_dag_event_get_datum(a_event_item->event, a_event_item->event_size);
pthread_rwlock_t * l_events_rwlock = &PVT(a_dag)->events_rwlock;
switch (l_datum->header.type_id) {
+ case DAP_CHAIN_DATUM_256_TOKEN_DECL:
case DAP_CHAIN_DATUM_TOKEN_DECL: {
dap_chain_datum_token_t *l_token = (dap_chain_datum_token_t*) l_datum->data;
return dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
@@ -298,10 +299,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