Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • cellframe/cellframe-sdk
  • MIKA83/cellframe-sdk
2 results
Show changes
Commits on Source (1)
Hide whitespace changes
Inline Side-by-side
Showing
with 130 additions and 297 deletions
modules/chain/dap_chain_ledger.c
View file @ 64d180ec
......@@ -918,7 +918,7 @@ static void s_treshold_emissions_proc(dap_ledger_t * a_ledger)
pthread_rwlock_rdlock(&PVT(a_ledger)->treshold_emissions_rwlock);
HASH_ITER(hh, PVT(a_ledger)->treshold_emissions, l_emission_item, l_emission_tmp) {
pthread_rwlock_unlock(&PVT(a_ledger)->treshold_emissions_rwlock);
int l_res = dap_chain_ledger_token_emission_add(a_ledger, l_emission_item->datum_token_emission,
int l_res = dap_chain_ledger_token_emission_add(a_ledger, (byte_t *)l_emission_item->datum_token_emission,
l_emission_item->datum_token_emission_size);
if (!l_res) {
pthread_rwlock_wrlock(&PVT(a_ledger)->treshold_emissions_rwlock);
......@@ -1003,11 +1003,14 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
continue;
dap_chain_ledger_token_emission_item_t *l_emission_item = DAP_NEW_Z(dap_chain_ledger_token_emission_item_t);
dap_chain_hash_fast_from_str(l_objs[i].key, &l_emission_item->datum_token_emission_hash);
l_emission_item->datum_token_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_objs[i].value_len);
memcpy(l_emission_item->datum_token_emission, l_objs[i].value, l_objs[i].value_len);
const char * c_token_ticker = l_emission_item->datum_token_emission->hdr.ticker;
size_t l_emission_size = l_objs[i].value_len;
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_size = l_emission_size;
if (l_token_item) {
HASH_ADD(hh, l_token_item->token_emissions, datum_token_emission_hash,
sizeof(dap_chain_hash_fast_t), l_emission_item);
......@@ -1111,13 +1114,12 @@ dap_ledger_t* dap_chain_ledger_create(uint16_t a_check_flags, char *a_net_name)
return l_ledger;
}
int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_chain_datum_token_emission_t *a_token_emission
, size_t a_token_emission_size)
int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size)
{
int ret = 0;
dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
const char * c_token_ticker = a_token_emission->hdr.ticker;
const char * c_token_ticker = ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.ticker;
dap_chain_ledger_token_item_t * l_token_item = NULL;
pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
HASH_FIND_STR(l_ledger_priv->tokens, c_token_ticker, l_token_item);
......@@ -1140,7 +1142,7 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
if(l_token_emission_item ) {
if(s_debug_more)
log_it(L_ERROR, "Can't add token emission datum of %"DAP_UINT64_FORMAT_U" %s ( %s ): already present in cache",
a_token_emission->hdr.value, c_token_ticker, l_hash_str);
l_token_emission_item->datum_token_emission->hdr.value, c_token_ticker, l_hash_str);
ret = -1;
}else if ( (! l_token_item) && ( l_threshold_emissions_count >= s_treshold_emissions_max)) {
if(s_debug_more)
......@@ -1148,20 +1150,22 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
s_treshold_emissions_max);
ret = -2;
}else{ // Chech emission correctness
switch (a_token_emission->hdr.type){
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_AUTH:{
dap_chain_ledger_token_item_t *l_token_item=NULL;
pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
HASH_FIND_STR(PVT(a_ledger)->tokens, a_token_emission->hdr.ticker, l_token_item);
HASH_FIND_STR(PVT(a_ledger)->tokens, l_emission->hdr.ticker, l_token_item);
pthread_rwlock_unlock(&PVT(a_ledger)->tokens_rwlock);
if (l_token_item){
assert(l_token_item->datum_token);
if( PVT(a_ledger)->net->pub.token_emission_signs_verify ){
dap_sign_t * l_sign =(dap_sign_t*) a_token_emission->data.type_auth.signs;
size_t l_offset= (byte_t*)a_token_emission - (byte_t*) l_sign;
dap_sign_t * l_sign =(dap_sign_t*) l_emission->data.type_auth.signs;
size_t l_offset= (byte_t*)l_emission - (byte_t*) l_sign;
uint16_t l_aproves = 0, l_aproves_valid = l_token_item->auth_signs_valid;
for (uint16_t i=0; i <a_token_emission->data.type_auth.signs_count && l_offset < a_token_emission_size; i++){
for (uint16_t i=0; i <l_emission->data.type_auth.signs_count && l_offset < l_emission_size; i++){
size_t l_sign_size = dap_sign_get_size(l_sign);
l_sign = (dap_sign_t*) ((byte_t*) l_sign + l_sign_size);
if (UINT16_MAX-l_offset> l_sign_size ){
......@@ -1171,10 +1175,10 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
for(uint16_t k=0; k< l_token_item->auth_signs_total; k++ ){
if ( dap_hash_fast_compare(&l_sign_pkey_hash, &l_token_item->auth_signs_pkey_hash[k])) {
// Verify if its token emission header signed
if (!dap_sign_verify_size(l_sign, a_token_emission_size)) {
if (!dap_sign_verify_size(l_sign, l_emission_size)) {
break;
}
if( dap_sign_verify(l_sign,&a_token_emission->hdr, sizeof (a_token_emission) ) ){
if (dap_sign_verify(l_sign, &l_emission->hdr, sizeof(l_emission))) {
l_aproves++;
break;
}
......@@ -1188,18 +1192,19 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
if (l_aproves < l_aproves_valid ){
if(s_debug_more)
log_it(L_WARNING, "Emission of %"DAP_UINT64_FORMAT_U" datoshi of %s:%s is wrong: only %u valid aproves when %u need",
a_token_emission->hdr.value, a_ledger->net_name, a_token_emission->hdr.ticker, l_aproves, l_aproves_valid );
l_emission->hdr.value, a_ledger->net_name, l_emission->hdr.ticker, l_aproves, l_aproves_valid );
ret = -1;
}
}
}else{
if(s_debug_more)
log_it(L_WARNING,"Can't find token declaration %s:%s thats pointed in token emission datum", a_ledger->net_name, a_token_emission->hdr.ticker);
log_it(L_WARNING,"Can't find token declaration %s:%s thats pointed in token emission datum", a_ledger->net_name, l_emission->hdr.ticker);
ret = DAP_CHAIN_CS_VERIFY_CODE_TX_NO_PREVIOUS;
}
}break;
default:{}
}
DAP_DELETE(l_emission);
}
DAP_DELETE(l_hash_str);
......@@ -1212,21 +1217,19 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, const dap_
* @param a_token_emision_size
* @return
*/
int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
const dap_chain_datum_token_emission_t *a_token_emission, size_t a_token_emission_size)
int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size)
{
int ret = 0;
dap_ledger_private_t *l_ledger_priv = PVT(a_ledger);
const char * c_token_ticker = a_token_emission->hdr.ticker;
const char * c_token_ticker = ((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.ticker;
dap_chain_ledger_token_item_t * l_token_item = NULL;
pthread_rwlock_rdlock(&l_ledger_priv->tokens_rwlock);
HASH_FIND_STR(l_ledger_priv->tokens, c_token_ticker, l_token_item);
pthread_rwlock_unlock(&l_ledger_priv->tokens_rwlock);
dap_chain_ledger_token_emission_item_t * l_token_emission_item = NULL;
// check if such emission is already present in table
dap_chain_hash_fast_t l_token_emission_hash={0};
dap_chain_hash_fast_t * l_token_emission_hash_ptr = &l_token_emission_hash;
dap_chain_hash_fast_t l_token_emission_hash = {};
dap_hash_fast(a_token_emission, a_token_emission_size, &l_token_emission_hash);
char * l_hash_str = dap_chain_hash_fast_to_str_new(&l_token_emission_hash);
pthread_rwlock_rdlock( l_token_item ? &l_token_item->token_emissions_rwlock
......@@ -1239,11 +1242,13 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
if(l_token_emission_item == NULL ) {
if ( l_token_item || l_threshold_emissions_count < s_treshold_emissions_max ) {
l_token_emission_item = DAP_NEW_Z(dap_chain_ledger_token_emission_item_t);
l_token_emission_item->datum_token_emission =
DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, a_token_emission_size);
size_t l_emission_size = a_token_emission_size;
l_token_emission_item->datum_token_emission = l_token_item
? dap_chain_datum_emission_read(a_token_emission, &l_emission_size)
: DAP_DUP_SIZE(a_token_emission, a_token_emission_size);
memcpy(l_token_emission_item->datum_token_emission, a_token_emission, a_token_emission_size);
memcpy(&l_token_emission_item->datum_token_emission_hash,
l_token_emission_hash_ptr, sizeof(l_token_emission_hash));
&l_token_emission_hash, sizeof(l_token_emission_hash));
l_token_emission_item->datum_token_emission_size = a_token_emission_size;
pthread_rwlock_wrlock( l_token_item ? &l_token_item->token_emissions_rwlock
: &l_ledger_priv->treshold_emissions_rwlock);
......@@ -1257,20 +1262,19 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
pthread_rwlock_unlock( l_token_item ? &l_token_item->token_emissions_rwlock
: &l_ledger_priv->treshold_emissions_rwlock);
// Add it to cache
dap_chain_datum_token_emission_t *l_emission_cache = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, a_token_emission_size);
memcpy(l_emission_cache, a_token_emission, a_token_emission_size);
dap_chain_datum_token_emission_t *l_emission_cache = DAP_DUP_SIZE(a_token_emission, a_token_emission_size);
char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_EMISSIONS_STR);
if (!dap_chain_global_db_gr_set(dap_strdup(l_hash_str), l_emission_cache, a_token_emission_size, l_gdb_group)) {
log_it(L_WARNING, "Ledger cache mismatch");
DAP_DELETE(l_emission_cache);
}
DAP_DELETE(l_gdb_group);
char * l_token_emission_address_str = dap_chain_addr_to_str( &(a_token_emission->hdr.address) );
char * l_token_emission_address_str = dap_chain_addr_to_str(&(l_token_emission_item->datum_token_emission->hdr.address) );
if(s_debug_more)
log_it(L_NOTICE, "Added token emission datum to %s: type=%s value=%.1Lf token=%s to_addr=%s ",
l_token_item?"emissions cache":"emissions treshold",
c_dap_chain_datum_token_emission_type_str[ a_token_emission->hdr.type ] ,
dap_chain_datoshi_to_coins(a_token_emission->hdr.value), c_token_ticker,
c_dap_chain_datum_token_emission_type_str[l_token_emission_item->datum_token_emission->hdr.type ] ,
dap_chain_datoshi_to_coins(l_token_emission_item->datum_token_emission->hdr.value), c_token_ticker,
l_token_emission_address_str);
DAP_DELETE(l_token_emission_address_str);
}else{
......@@ -1283,7 +1287,8 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
if (l_token_item) {
if(s_debug_more)
log_it(L_ERROR, "Duplicate token emission datum of %"DAP_UINT64_FORMAT_U" %s ( %s )",
a_token_emission->hdr.value, c_token_ticker, l_hash_str);
((dap_chain_datum_token_emission_t *)a_token_emission)->hdr.value,
c_token_ticker, l_hash_str);
}
ret = -1;
}
......@@ -1291,7 +1296,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
return ret;
}
int dap_chain_ledger_token_emission_load(dap_ledger_t *a_ledger, const dap_chain_datum_token_emission_t *a_token_emission, size_t a_token_emission_size)
int dap_chain_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size)
{
if (PVT(a_ledger)->last_emit.found) {
return dap_chain_ledger_token_emission_add(a_ledger, a_token_emission, a_token_emission_size);
......
modules/chain/include/dap_chain_ledger.h
View file @ 64d180ec
......@@ -127,16 +127,13 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger);
/**
* Add token emission datum
*/
int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger,
const dap_chain_datum_token_emission_t *a_token_emission, size_t a_token_emission_size);
int dap_chain_ledger_token_emission_load(dap_ledger_t *a_ledger,
const dap_chain_datum_token_emission_t *a_token_emission, size_t a_token_emission_size);
int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size);
int dap_chain_ledger_token_emission_load(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size);
// Check if it addable
int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger,
const dap_chain_datum_token_emission_t *a_token_emission, size_t a_token_emission_size);
int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size);
dap_chain_datum_token_emission_t * dap_chain_ledger_token_emission_find(dap_ledger_t *a_ledger,
dap_chain_datum_token_emission_t *dap_chain_ledger_token_emission_find(dap_ledger_t *a_ledger,
const char *a_token_ticker, const dap_chain_hash_fast_t *a_token_emission_hash);
const char* dap_chain_ledger_tx_get_token_ticker_by_hash(dap_ledger_t *a_ledger,dap_chain_hash_fast_t *a_tx_hash);
......
modules/common/dap_chain_datum_token.c
View file @ 64d180ec
......@@ -201,3 +201,57 @@ err:
return NULL;
}
size_t dap_chain_datum_emission_get_size(uint8_t *a_emission_serial)
{
size_t l_ret = 0;
dap_chain_datum_token_emission_t *l_emission = (dap_chain_datum_token_emission_t *)a_emission_serial;
if (l_emission->hdr.version == 0) {
l_ret = sizeof(struct dap_chain_emission_header_v0);
} else {
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;
}
return l_ret;
}
dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(uint8_t *a_emission_serial, size_t *a_emission_size)
{
assert(a_emission_serial);
assert(a_emission_size);
dap_chain_datum_token_emission_t *l_emission;
if (((dap_chain_datum_token_emission_t *)a_emission_serial)->hdr.version == 0) {
size_t l_add_size = DAP_CHAIN_DATUM_NONCE_SIZE + sizeof(uint256_t) - sizeof(uint64_t);
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, *a_emission_size + l_add_size);
size_t l_old_hdr_size = sizeof(struct dap_chain_emission_header_v0);
l_emission->hdr.version = 1;
memcpy(l_emission, a_emission_serial, l_old_hdr_size);
memcpy(l_emission + l_old_hdr_size + l_add_size,
a_emission_serial + l_old_hdr_size,
*a_emission_size - l_old_hdr_size);
*a_emission_size += l_add_size;
} else
l_emission = DAP_DUP_SIZE(a_emission_serial, *a_emission_size);
return l_emission;
}
modules/common/include/dap_chain_datum_token.h
View file @ 64d180ec
......@@ -195,6 +195,15 @@ static inline uint16_t dap_chain_datum_token_flag_from_str(const char* a_str)
#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_REMOVE 0x0024
#define DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_CLEAR 0x0025
#define DAP_CHAIN_DATUM_NONCE_SIZE 64
struct DAP_ALIGN_PACKED dap_chain_emission_header_v0 {
uint8_t version;
uint8_t type; // Emission Type
char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
dap_chain_addr_t address; // Emission holder's address
uint64_t value;
};
// Token emission
typedef struct dap_chain_datum_token_emission{
......@@ -203,7 +212,11 @@ typedef struct dap_chain_datum_token_emission{
uint8_t type; // Emission Type
char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
dap_chain_addr_t address; // Emission holder's address
uint64_t value;
union {
uint64_t value;
uint256_t value256;
};
uint8_t nonce[DAP_CHAIN_DATUM_NONCE_SIZE];
} DAP_ALIGN_PACKED hdr;
union {
struct {
......@@ -240,3 +253,5 @@ dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t * a_token, siz
void dap_chain_datum_token_flags_dump(dap_string_t * a_str_out, uint16_t a_flags);
void dap_chain_datum_token_certs_dump(dap_string_t * a_str_out, byte_t * a_data_n_tsd, size_t a_certs_size);
dap_sign_t ** dap_chain_datum_token_simple_signs_parse(dap_chain_datum_token_t * a_datum_token, size_t a_datum_token_size, size_t *a_signs_count, size_t * a_signs_valid);
dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(uint8_t *a_emission_serial, size_t *a_emission_size);
size_t dap_chain_datum_emission_get_size(uint8_t *a_emission_serial);
modules/consensus/none/dap_chain_cs_none.c
View file @ 64d180ec
......@@ -322,8 +322,7 @@ static dap_chain_atom_verify_res_t s_chain_callback_atom_add(dap_chain_t * a_cha
return ATOM_REJECT;
}break;
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
dap_chain_datum_token_emission_t *l_token_emission = (dap_chain_datum_token_emission_t*) l_datum->data;
if (dap_chain_ledger_token_emission_load(a_chain->ledger, l_token_emission, l_datum->header.data_size))
if (dap_chain_ledger_token_emission_load(a_chain->ledger, l_datum->data, l_datum->header.data_size))
return ATOM_REJECT;
}break;
case DAP_CHAIN_DATUM_TX:{
......
modules/net/dap_chain_net.c
View file @ 64d180ec
......@@ -2546,7 +2546,7 @@ int dap_chain_net_verify_datum_for_add(dap_chain_net_t *a_net, dap_chain_datum_t
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_TOKEN_EMISSION : 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 );
a_datum->data, a_datum->header.data_size );
default: return 0;
}
}
......
modules/net/dap_chain_node_cli_cmd.c
View file @ 64d180ec
......@@ -3177,10 +3177,10 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
return -43;
}
// Wallet address that recieves the emission
// Token emission
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission", &l_emission_hash_str);
// Wallet address that recieves the emission
// Emission certs
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
// Wallet address that recieves the emission
......@@ -3189,7 +3189,7 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
// Token ticker
dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-token", &l_ticker);
// Token emission
// Emission value
if(dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission_value", &str_tmp)) {
l_emission_value = strtoull(str_tmp, NULL, 10);
}
......@@ -3293,10 +3293,13 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
sizeof(l_emission->data.type_auth.signs_count);
l_emission = DAP_NEW_Z_SIZE(dap_chain_datum_token_emission_t, l_emission_size);
l_emission->hdr.version = 1;
strncpy(l_emission->hdr.ticker, l_ticker, sizeof(l_emission->hdr.ticker) - 1);
l_emission->hdr.value = l_emission_value;
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);
memcpy(&l_emission->hdr.nonce, &l_time, sizeof(time_t));
// Then add signs
size_t l_offset = 0;
for(size_t i = 0; i < l_certs_size; i++) {
......@@ -3333,15 +3336,15 @@ 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 emission %s is placed in datum pool", 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 emission %s is placed in datum pool", 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 emission %s is not placed in datum pool", 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 emission %s is not placed in datum pool", 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);
......
modules/net/dap_chain_node_cli_cmd_tx.c
View file @ 64d180ec
......@@ -1209,7 +1209,8 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
l_token_num++;
break;
}
dap_chain_datum_token_emission_t *l_token_em = (dap_chain_datum_token_emission_t*) l_datum->data;
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
......@@ -1253,10 +1254,10 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
dap_string_append_printf(l_str_out, "\n");
l_emission_num++;
}
}
break;
DAP_DELETE(l_token_em);
} break;
// transaction
// transaction
case DAP_CHAIN_DATUM_TX:{
// datum out of page
......@@ -1265,247 +1266,8 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
break;
}
dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*)l_datum->data;
// dap_chain_tx_hash_processed_ht_t *l_tx_hash_processed = a_tx_hash_processed;
//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);
// a_tx_hash_processed = l_tx_hash_processed;
// l_tx_num++;
/*dap_chain_datum_tx_t *l_tx = (dap_chain_datum_tx_t*) l_datum->data;
// find Token items - present in emit transaction
dap_list_t *l_list_tx_token = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
// find OUT items
dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, NULL);
dap_tx_data_t *l_tx_data = NULL;
// calc tx hash
dap_chain_hash_fast_t l_tx_hash;
dap_hash_fast(l_tx, dap_chain_datum_tx_get_size(l_tx), &l_tx_hash);
char *tx_hash_str;
char l_tx_hash_str[70];
dap_chain_hash_fast_to_str(&l_tx_hash, l_tx_hash_str, 70);
if(!dap_strcmp(a_hash_out_type, "hex"))
tx_hash_str = dap_strdup(l_tx_hash_str);
else
tx_hash_str = dap_enc_base58_from_hex_str_to_str(l_tx_hash_str);
dap_string_append_printf(l_str_out, "transaction: %s hash: %s\n", l_list_tx_token ? "(emit)" : "", tx_hash_str);
DAP_DELETE(tx_hash_str);
dap_list_t *l_list_tmp = l_list_out_items;
while(l_list_tmp) {
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)
{
// 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));
memcpy(&l_tx_data->addr, &l_tx_out->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->datum = DAP_NEW_SIZE(dap_chain_datum_t, l_atom_size);
memcpy(l_tx_data->datum, l_datum, l_atom_size);
// save token name
if(l_list_tx_token) {
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
dap_list_t *l_list_in_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_IN, NULL);
dap_list_t *l_list_tmp_in = l_list_in_items;
// find token_ticker in prev OUT items
while(l_list_tmp_in) {
const dap_chain_tx_in_t *l_tx_in =
(const dap_chain_tx_in_t*) l_list_tmp_in->data;
dap_chain_hash_fast_t tx_prev_hash = l_tx_in->header.tx_prev_hash;
//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);
if(l_tx_data_prev != NULL) {
// fill token in l_tx_data from prev transaction
if(l_tx_data) {
// get token from prev tx
memcpy(l_tx_data->token_ticker, l_tx_data_prev->token_ticker,
sizeof(l_tx_data->token_ticker));
break;
}
}
l_list_tmp_in = dap_list_next(l_list_tmp_in);
}
if(l_list_in_items)
dap_list_free(l_list_in_items);
}
HASH_ADD(hh, l_tx_data_hash, tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_data);
}
l_list_tmp = dap_list_next(l_list_tmp);
}
if(l_list_out_items)
dap_list_free(l_list_out_items);
// found a_tx_hash now
// transaction time
if(l_tx->header.ts_created > 0) {
time_t rawtime = (time_t) l_tx->header.ts_created;
struct tm l_timeinfo = { 0 };
localtime_r(&rawtime, &l_timeinfo);
dap_string_append_printf(l_str_out, " %s", asctime(&l_timeinfo));
}
// find all OUT items in transaction
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_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;
dap_string_append_printf(l_str_out, " OUT item %lld %s to %s\n",
l_tx_out->header.value,
dap_strlen(l_token_str) > 0 ? l_token_str : "?",
l_dst_to_str ? l_dst_to_str : "?"
);
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;
// find cur addr in prev OUT items
while(l_list_tmp) {
const dap_chain_tx_in_t *l_tx_in = (const dap_chain_tx_in_t*) l_list_tmp->data;
dap_chain_hash_fast_t tx_prev_hash = l_tx_in->header.tx_prev_hash;
char l_tx_hash_str[70];
char *tx_hash_base58_str = NULL;
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");
tx_hash_base58_str = dap_strdup("Null");
}
if(!dap_strcmp(a_hash_out_type, "hex"))
dap_string_append_printf(l_str_out, " IN item \n prev tx_hash %s\n", l_tx_hash_str);
else
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);
if(l_tx_data_prev != NULL) {
dap_chain_datum_t *l_datum_prev = get_prev_tx(l_tx_data_prev);
dap_chain_datum_tx_t *l_tx_prev =
l_datum_prev ? (dap_chain_datum_tx_t*) l_datum_prev->data : NULL;
// find OUT items in prev datum
dap_list_t *l_list_out_prev_items = dap_chain_datum_tx_items_get(l_tx_prev,
TX_ITEM_TYPE_OUT, NULL);
// 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;
// print value from prev out item
dap_string_append_printf(l_str_out, " prev OUT item value=%lld",
l_tx_prev_out ? l_tx_prev_out->header.value : 0);
}
l_list_tmp = dap_list_next(l_list_tmp);
}
//find SIG type
dap_list_t *l_list_sig_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_SIG, NULL);
unsigned int l_list_sig_items_len = dap_list_length(l_list_sig_items);
//TX_ITEM_TYPE_SIG
dap_string_append_printf(l_str_out, "Count SIGN: %i \n", l_list_sig_items_len);
l_list_tmp = l_list_sig_items;
while (l_list_tmp) {
dap_chain_tx_sig_t *l_sig_tx = (dap_chain_tx_sig_t *)l_list_tmp->data;
dap_chain_hash_fast_t *l_sign_hash_fast = DAP_NEW(dap_chain_hash_fast_t);
dap_sign_t *l_sign = dap_chain_datum_tx_item_sign_get_sig(l_sig_tx);
if (dap_sign_get_pkey_hash(l_sign, l_sign_hash_fast)){
char l_tx_sign_hash_str[70];
dap_chain_hash_fast_to_str(l_sign_hash_fast, l_tx_sign_hash_str, 70);
dap_string_append_printf(l_str_out, "%s\n", l_tx_sign_hash_str);
}else{
dap_string_append_printf(l_str_out, "Can't get pkey for sign \n");
}
DAP_FREE(l_sign_hash_fast);
l_list_tmp = dap_list_next(l_list_tmp);
}
dap_list_free(l_list_sig_items);
//find PKEY
dap_list_t *l_list_pkey_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_PKEY, NULL);
unsigned int l_list_pkey_items_len = dap_list_length(l_list_pkey_items);
dap_string_append_printf(l_str_out, "Count PKEY: %i \n", l_list_pkey_items_len);
dap_list_free(l_list_pkey_items);
//find TOKEN
dap_list_t *l_list_token_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN, NULL);
unsigned int l_list_token_items_len = dap_list_length(l_list_token_items);
dap_string_append_printf(l_str_out, "Count TOKEN: %i \n", l_list_token_items_len);
l_list_tmp = l_list_token_items;
while(l_list_tmp){
dap_chain_tx_token_t *l_token = (dap_chain_tx_token_t*)l_list_tmp->data;
l_list_tmp = dap_list_next(l_list_tmp);
}
dap_list_free(l_list_token_items);
//find IN_COND
dap_list_t *l_list_in_cond_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_IN_COND, NULL);
unsigned int l_list_in_cond_items_len = dap_list_length(l_list_in_cond_items);
dap_string_append_printf(l_str_out, "Count IN_COND: %i \n", l_list_in_cond_items_len);
dap_list_free(l_list_in_cond_items);
//find OUT_COND
dap_list_t *l_list_out_cond_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT_COND, NULL);
unsigned int l_list_out_cond_items_len = dap_list_length(l_list_out_cond_items);
dap_string_append_printf(l_str_out, "Count OUT_COND: %i \n", l_list_out_cond_items_len);
dap_list_free(l_list_out_cond_items);
//find OUT_EXT
dap_list_t *l_list_out_ext_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT_EXT, NULL);
unsigned int l_list_out_ext_items_len = dap_list_length(l_list_out_ext_items);
dap_string_append_printf(l_str_out, "Count OUT_EXIT: %i \n", l_list_out_ext_items_len);
dap_list_free(l_list_out_ext_items);
//find RECEIPT
dap_list_t *l_list_receipt_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_RECEIPT, NULL);
unsigned int l_list_receipt_items_len = dap_list_length(l_list_receipt_items);
dap_string_append_printf(l_str_out, "Count RECEIPT: %i \n", l_list_receipt_items_len);
dap_list_free(l_list_receipt_items);
//find TOKEN_EXT
dap_list_t *l_list_token_ext_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_TOKEN_EXT, NULL);
unsigned int l_list_token_ext_items_len = dap_list_length(l_list_token_ext_items);
dap_string_append_printf(l_str_out, "Count TOKEN_EXT: %i \n", l_list_token_ext_items_len);
dap_list_free(l_list_token_ext_items);
dap_string_append_printf(l_str_out, "\n");
if(l_list_tx_token)
dap_list_free(l_list_tx_token);
if(l_list_out_items)
dap_list_free(l_list_out_items);
if(l_list_in_items)
dap_list_free(l_list_in_items);
l_tx_hash_found = true;
l_tx_num++;*/
}
break;
default:
......
modules/type/blocks/dap_chain_cs_blocks.c
View file @ 64d180ec
......@@ -623,8 +623,7 @@ static int s_add_atom_to_ledger(dap_chain_cs_blocks_t * a_blocks, dap_ledger_t
l_ret=dap_chain_ledger_token_load(a_ledger, l_token, l_datum->header.data_size);
} break;
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
dap_chain_datum_token_emission_t *l_token_emission = (dap_chain_datum_token_emission_t*) l_datum->data;
l_ret=dap_chain_ledger_token_emission_load(a_ledger, l_token_emission, l_datum->header.data_size);
l_ret=dap_chain_ledger_token_emission_load(a_ledger, 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;
......
modules/type/dag/dap_chain_cs_dag.c
View file @ 64d180ec
......@@ -304,8 +304,7 @@ static int s_dap_chain_add_atom_to_ledger(dap_chain_cs_dag_t * a_dag, dap_ledger
}
break;
case DAP_CHAIN_DATUM_TOKEN_EMISSION: {
dap_chain_datum_token_emission_t *l_token_emission = (dap_chain_datum_token_emission_t*) l_datum->data;
return dap_chain_ledger_token_emission_load(a_ledger, l_token_emission, l_datum->header.data_size);
return dap_chain_ledger_token_emission_load(a_ledger, l_datum->data, l_datum->header.data_size);
}
break;
case DAP_CHAIN_DATUM_TX: {
......