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 (9)
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1212 additions and 215 deletions
CMakeLists.txt
View file @ 504a55ab
......@@ -18,7 +18,7 @@ endif()
if(NOT DEFINED CELLFRAME_MODULES)
include (dap-sdk/cmake/OS_Detection.cmake)
set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-esbocs cs-none srv-app srv-app-db srv-datum srv-stake srv-xchange")
set(CELLFRAME_MODULES "core chains mining network srv cs-dag-poa cs-block-poa cs-dag-pos cs-block-pos cs-esbocs cs-none srv-app srv-app-db srv-datum srv-stake srv-voting srv-bridge srv-xchange")
if(LINUX OR DARWIN)
set(CELLFRAME_MODULES "${CELLFRAME_MODULES} srv-vpn")
......@@ -182,6 +182,19 @@ if (CELLFRAME_MODULES MATCHES "srv-stake")
set(CELLFRAME_LIBS ${CELLFRAME_LIBS} dap_chain_net_srv_stake)
endif()
# Enable service bridge
if (CELLFRAME_MODULES MATCHES "srv-bridge")
message("[+] Module 'srv-bridge'")
set(CELLFRAME_LIBS ${CELLFRAME_LIBS} dap_chain_net_srv_bridge)
endif()
# Enable service voting
if (CELLFRAME_MODULES MATCHES "srv-voting")
message("[+] Module 'srv-voting'")
set(CELLFRAME_LIBS ${CELLFRAME_LIBS} dap_chain_net_srv_voting)
endif()
# Enable service for dynamic modules
if (CELLFRAME_MODULES MATCHES "modules-dynamic")
message("[+] Module 'dap_modules_dynamic_cdb'")
......
dap-sdk @ 72796e25
Compare 9a4290d8...72796e25
Subproject commit 9a4290d80e07e8a2192477ae013cea9d78ce2cba
Subproject commit 72796e25f1a7e792200c24e109b50d94ee7f5fd5
modules/CMakeLists.txt
View file @ 504a55ab
......@@ -20,7 +20,6 @@ if (CELLFRAME_MODULES MATCHES "network")
add_subdirectory(mempool)
add_subdirectory(net)
add_subdirectory(net/srv)
add_subdirectory(json_rpc)
# Stream channels
add_subdirectory(channel/chain-net)
endif()
......@@ -110,7 +109,12 @@ if (CELLFRAME_MODULES MATCHES "srv-stake")
add_subdirectory(service/stake)
endif()
# Unit tests
if( BUILD_TESTS)
add_subdirectory(test)
# Service for polls and voting
if (CELLFRAME_MODULES MATCHES "srv-voting")
add_subdirectory(service/voting)
endif()
# Service for bridge
if (CELLFRAME_MODULES MATCHES "srv-bridge")
add_subdirectory(service/bridge)
endif()
modules/chain/dap_chain.c
View file @ 504a55ab
......@@ -542,6 +542,21 @@ bool dap_chain_has_file_store(dap_chain_t * a_chain)
}
/**
* @brief get type of chain
*
* @param l_chain
* @return char*
*/
const char *dap_chain_get_cs_type(dap_chain_t *l_chain)
{
if (!l_chain){
log_it(L_DEBUG, "dap_get_chain_type. Chain object is 0");
return NULL;
}
return (const char *)DAP_CHAIN_PVT(l_chain)->cs_name;
}
/**
* @brief dap_chain_save_all
* @param l_chain
......
modules/chain/dap_chain_ch.c
View file @ 504a55ab
......@@ -23,43 +23,17 @@
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#ifdef WIN32
#include <winsock2.h>
#include <windows.h>
#include <mswsock.h>
#include <ws2tcpip.h>
#include <io.h>
#include <pthread.h>
#endif
#include "dap_common.h"
#include "dap_strfuncs.h"
#include "dap_list.h"
#include "dap_config.h"
#include "dap_hash.h"
#include "dap_time.h"
#include "utlist.h"
#include "dap_worker.h"
#include "dap_events.h"
#include "dap_proc_thread.h"
#include "dap_client_pvt.h"
#include "dap_chain.h"
#include "dap_chain_datum.h"
#include "dap_chain_cs.h"
#include "dap_chain_cell.h"
#include "dap_global_db_legacy.h"
#include "dap_global_db_pkt.h"
#include "dap_global_db_ch.h"
#include "dap_stream.h"
#include "dap_stream_pkt.h"
#include "dap_stream_worker.h"
......@@ -1126,7 +1100,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
// Response with gdb element hashes and sizes
case DAP_CHAIN_CH_PKT_TYPE_UPDATE_GLOBAL_DB: {
if (l_chain_pkt_data_size > sizeof(dap_chain_ch_update_element_t) * s_update_pack_size) {
if (l_chain_pkt_data_size % sizeof(dap_chain_ch_update_element_t)) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
......
modules/chain/include/dap_chain.h
View file @ 504a55ab
......@@ -29,9 +29,6 @@
#include "dap_config.h"
#include "dap_chain_common.h"
#include "dap_chain_datum.h"
#include "dap_chain_datum_tx.h"
#include "dap_cert.h"
#include "dap_global_db_cluster.h"
typedef struct dap_chain dap_chain_t;
......@@ -118,10 +115,6 @@ typedef void (*dap_chain_callback_notify_t)(void *a_arg, dap_chain_t *a_chain, d
typedef uint64_t (*dap_chain_callback_get_count)(dap_chain_t *a_chain);
typedef dap_list_t *(*dap_chain_callback_get_list)(dap_chain_t *a_chain, size_t a_count, size_t a_page, bool a_reverse);
typedef dap_list_t *(*dap_chain_callback_get_poa_certs)(dap_chain_t *a_chain, size_t *a_auth_certs_count, uint16_t *count_verify);
typedef void (*dap_chain_callback_set_min_validators_count)(dap_chain_t *a_chain, uint16_t a_new_value);
typedef uint256_t (*dap_chain_callback_get_minimum_fee)(dap_chain_t *a_chain);
typedef uint256_t (*dap_chain_callback_get_collectiong_level)(dap_chain_t *a_chain);
typedef dap_enc_key_t* (*dap_chain_callback_get_signing_certificate)(dap_chain_t *a_chain);
typedef void (*dap_chain_callback_load_from_gdb)(dap_chain_t *a_chain);
typedef uint256_t (*dap_chain_callback_calc_reward)(dap_chain_t *a_chain, dap_hash_fast_t *a_block_hash, dap_pkey_t *a_block_sign_pkey);
......@@ -198,10 +191,6 @@ typedef struct dap_chain {
// Consensus specific callbacks
dap_chain_callback_get_poa_certs callback_get_poa_certs;
dap_chain_callback_set_min_validators_count callback_set_min_validators_count;
dap_chain_callback_get_minimum_fee callback_get_minimum_fee;
dap_chain_callback_get_collectiong_level callback_get_collectiong_level;
dap_chain_callback_get_signing_certificate callback_get_signing_certificate;
dap_chain_callback_calc_reward callback_calc_reward;
dap_chain_callback_load_from_gdb callback_load_from_gdb;
......@@ -269,5 +258,5 @@ DAP_STATIC_INLINE bool dap_chain_get_atom_last_hash(dap_chain_t *a_chain, dap_ch
}
ssize_t dap_chain_atom_save(dap_chain_cell_t *a_chain_cell, const uint8_t *a_atom, size_t a_atom_size, dap_hash_fast_t *a_new_atom_hash);
int dap_cert_chain_file_save(dap_chain_datum_t *datum, char *net_name);
const char* dap_chain_get_path(dap_chain_t *a_chain);
const char *dap_chain_get_path(dap_chain_t *a_chain);
const char *dap_chain_get_cs_type(dap_chain_t *l_chain);
modules/chain/tests/dap_chain_ledger_tests.c
View file @ 504a55ab
......@@ -18,7 +18,7 @@ dap_chain_datum_token_t *dap_ledger_test_create_datum_decl(dap_cert_t *a_cert,
l_token->version = 2;
l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_DECL;
l_token->subtype = DAP_CHAIN_DATUM_TOKEN_SUBTYPE_NATIVE;
dap_snprintf(l_token->ticker, sizeof(l_token->ticker), "%s", a_token_ticker);
snprintf(l_token->ticker, sizeof(l_token->ticker), "%s", a_token_ticker);
l_token->signs_valid = 1;
l_token->total_supply = a_total_supply;
l_token->header_native_decl.decimals = 18;
......@@ -368,7 +368,7 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
void dap_ledger_test_run(void){
dap_chain_net_srv_stake_pos_delegate_init();
dap_chain_net_id_t l_iddn = {0};
dap_sscanf("0xFA0", "0x%16"DAP_UINT64_FORMAT_x, &l_iddn.uint64);
sscanf("0xFA0", "0x%16"DAP_UINT64_FORMAT_x, &l_iddn.uint64);
dap_print_module_name("dap_ledger");
uint16_t l_flags = 0;
l_flags |= DAP_LEDGER_CHECK_TOKEN_EMISSION;
......
modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
View file @ 504a55ab
......@@ -823,7 +823,7 @@ void s_set_usage_data_to_gdb(const dap_chain_net_srv_usage_t *a_usage)
client_statistic_value_t l_bin_value_new = {0};
size_t l_value_size = 0;
// forming key
dap_sprintf(l_bin_key.key, "0x%016"DAP_UINT64_FORMAT_X"", a_usage->service->uid.uint64);
sprintf(l_bin_key.key, "0x%016"DAP_UINT64_FORMAT_X"", a_usage->service->uid.uint64);
dap_chain_hash_fast_to_str_do(&a_usage->client_pkey_hash, l_bin_key.key + 18);
// check writed value
client_statistic_value_t *l_bin_value = (client_statistic_value_t *)dap_global_db_get_sync(SRV_STATISTIC_GDB_GROUP, l_bin_key.key, &l_value_size, NULL, NULL);
......
modules/channel/chain-net/dap_stream_ch_chain_net.c
View file @ 504a55ab
......@@ -43,10 +43,8 @@
#include "dap_common.h"
#include "dap_strfuncs.h"
#include "dap_cert.h"
#include "uthash.h"
#include "dap_http_client.h"
#include "dap_global_db.h"
#include "dap_chain_cs_esbocs.h"
#include "dap_chain_net_srv_order.h"
#include "dap_stream.h"
#include "dap_stream_ch_pkt.h"
#include "dap_stream_ch_proc.h"
......@@ -207,12 +205,12 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void* a_arg)
log_it(L_ERROR, "Invalid net id in packet");
} else {
dap_list_t * l_orders = NULL;
dap_enc_key_t * enc_key_pvt = NULL;
dap_enc_key_t *l_enc_key_pvt = NULL;
dap_chain_t *l_chain = NULL;
DL_FOREACH(l_net->pub.chains, l_chain)
if(l_chain->callback_get_signing_certificate != NULL){
enc_key_pvt = l_chain->callback_get_signing_certificate(l_chain);
if(enc_key_pvt)
if (!dap_strcmp(dap_chain_get_cs_type(l_chain), "esbocs")) {
l_enc_key_pvt = dap_chain_esbocs_get_sign_key(l_chain);
if (l_enc_key_pvt)
break;
}
dap_sign_t *l_sign = NULL;
......@@ -228,10 +226,9 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void* a_arg)
.uint64 = dap_chain_net_get_cur_addr_int(l_net)
};
if(enc_key_pvt)
{
if (l_enc_key_pvt) {
flags = flags | F_CERT;//faund sert
l_sign = dap_sign_create(enc_key_pvt, (uint8_t*)l_ch_chain_net_pkt->data,
l_sign = dap_sign_create(l_enc_key_pvt, (uint8_t*)l_ch_chain_net_pkt->data,
l_ch_chain_net_pkt->hdr.data_size, 0);
if(l_sign)
{
......
modules/common/dap_chain_common.c
View file @ 504a55ab
......@@ -52,14 +52,15 @@ size_t dap_chain_hash_slow_to_str( dap_chain_hash_slow_t *a_hash, char *a_str, s
{
const size_t c_hash_str_size = sizeof(*a_hash) * 2 + 1 /*trailing zero*/+ 2 /* heading 0x */;
if(a_str_max < c_hash_str_size) {
if (a_str_max < c_hash_str_size) {
log_it(L_ERROR, "String for hash too small, need %zu but have only %zu", c_hash_str_size, a_str_max);
return 0;
}
size_t i;
snprintf(a_str, 3, "0x");
sprintf(a_str, "0x");
for(i = 0; i < sizeof(a_hash->raw); ++i)
snprintf( a_str + i * 2 + 2, 3, "%02x", a_hash->raw[i] );
for (i = 0; i < sizeof(a_hash->raw); ++i)
sprintf( a_str + i * 2 + 2, "%02x", a_hash->raw[i] );
a_str[c_hash_str_size] = '\0';
......@@ -71,7 +72,7 @@ size_t dap_chain_hash_slow_to_str( dap_chain_hash_slow_t *a_hash, char *a_str, s
* @param a_addr
* @return
*/
char *dap_chain_addr_to_str(const dap_chain_addr_t *a_addr)
const char *dap_chain_addr_to_str(const dap_chain_addr_t *a_addr)
{
dap_return_val_if_pass(!a_addr, NULL);
if (dap_chain_addr_is_blank(a_addr))
......
modules/common/dap_chain_datum.c
View file @ 504a55ab
This diff is collapsed.
modules/common/dap_chain_datum_anchor.c
View file @ 504a55ab
......@@ -90,3 +90,41 @@ void dap_chain_datum_anchor_certs_dump(dap_string_t * a_str_out, byte_t * a_sign
dap_sign_type_to_str(l_sign->header.type), l_sign->header.sign_size);
}
}
void dap_chain_datum_anchor_certs_dump_json(json_object * a_json_out, byte_t * a_signs, size_t a_certs_size, const char *a_hash_out_type)
{
json_object_object_add(a_json_out, "signatures", json_object_new_string(""));
if (!a_certs_size) {
json_object_object_add(a_json_out, "Cert status", json_object_new_string("NONE"));
return;
}
json_object* json_arr_certs_out = json_object_new_array();
size_t l_offset = 0;
for (int i = 1; l_offset < (a_certs_size); i++) {
json_object* json_obj_sign = json_object_new_object();
dap_sign_t *l_sign = (dap_sign_t*)(a_signs + l_offset);
l_offset += dap_sign_get_size(l_sign);
if (l_sign->header.sign_size == 0) {
json_object_object_add(json_obj_sign, "sign status", json_object_new_string("CORRUPTED - 0 size signature"));
json_object_array_add(json_arr_certs_out, json_obj_sign);
continue;
}
dap_chain_hash_fast_t l_pkey_hash = {0};
if (dap_sign_get_pkey_hash(l_sign, &l_pkey_hash) == false) {
json_object_object_add(json_obj_sign, "sign status", json_object_new_string("CORRUPTED - can't calc hash"));
json_object_array_add(json_arr_certs_out, json_obj_sign);
continue;
}
const char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_pkey_hash)
: dap_chain_hash_fast_to_str_static(&l_pkey_hash);
json_object_object_add(json_obj_sign, "sign #", json_object_new_uint64(i));
json_object_object_add(json_obj_sign, "hash", json_object_new_string(l_hash_str));
json_object_object_add(json_obj_sign, "type", json_object_new_string(dap_sign_type_to_str(l_sign->header.type)));
json_object_object_add(json_obj_sign, "sign size", json_object_new_uint64(l_sign->header.sign_size));
json_object_array_add(json_arr_certs_out, json_obj_sign);
}
json_object_object_add(a_json_out,"SIGNS",json_arr_certs_out);
}
modules/common/dap_chain_datum_decree.c
View file @ 504a55ab
......@@ -41,11 +41,7 @@
dap_sign_t *dap_chain_datum_decree_get_signs(dap_chain_datum_decree_t *a_decree, size_t* a_signs_size)
{
if (!a_decree || !a_signs_size) {
log_it(L_CRITICAL, "Invalid arguments");
return NULL;
}
dap_return_val_if_fail(a_decree && a_signs_size, NULL);
dap_sign_t *l_signs_section = (dap_sign_t*)(a_decree->data_n_signs + a_decree->header.data_size);
*a_signs_size = a_decree->header.signs_size;
return l_signs_section;
......@@ -53,29 +49,23 @@ dap_sign_t *dap_chain_datum_decree_get_signs(dap_chain_datum_decree_t *a_decree,
int dap_chain_datum_decree_get_fee(dap_chain_datum_decree_t *a_decree, uint256_t *a_fee_value)
{
if(!a_decree || !a_fee_value) {
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_fee_value); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_fee_value, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE);
return l_tsd && l_tsd->size == sizeof(uint256_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_fee_value); 0; }) : 1;
}
int dap_chain_datum_decree_get_value(dap_chain_datum_decree_t *a_decree, uint256_t *a_value)
{
dap_return_val_if_fail(a_decree && a_value, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_value); 0; }) : 1;
return l_tsd && l_tsd->size == sizeof(uint256_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_value); 0; }) : 1;
}
int dap_chain_datum_decree_get_fee_addr(dap_chain_datum_decree_t *a_decree, dap_chain_addr_t *a_fee_wallet)
{
if(!a_decree || !a_fee_wallet) {
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_fee_wallet); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_fee_wallet, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET);
return l_tsd && l_tsd->size == sizeof(dap_chain_addr_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_fee_wallet); 0; }) : 1;
}
static void *s_cb_copy_pkeys(const void *a_pkey, UNUSED_ARG void *a_data) {
......@@ -84,10 +74,7 @@ static void *s_cb_copy_pkeys(const void *a_pkey, UNUSED_ARG void *a_data) {
dap_list_t *dap_chain_datum_decree_get_owners(dap_chain_datum_decree_t *a_decree, uint16_t *a_owners_num)
{
if(!a_decree || !a_owners_num){
log_it(L_CRITICAL, "Invalid arguments");
return NULL;
}
dap_return_val_if_fail(a_decree && a_owners_num, NULL);
dap_list_t *l_tsd_list = dap_tsd_find_all(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER);
*a_owners_num = (uint16_t)dap_list_length(l_tsd_list);
dap_list_t *l_ret = dap_list_copy_deep(l_tsd_list, s_cb_copy_pkeys, NULL);
......@@ -95,77 +82,80 @@ dap_list_t *dap_chain_datum_decree_get_owners(dap_chain_datum_decree_t *a_decree
return l_ret;
}
int dap_chain_datum_decree_get_min_owners(dap_chain_datum_decree_t *a_decree, uint16_t *a_min_owners_num)
int dap_chain_datum_decree_get_min_owners(dap_chain_datum_decree_t *a_decree, uint256_t *a_min_owners_num)
{
if(!a_decree || !a_min_owners_num){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_min_owners_num); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_min_owners_num, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER);
return l_tsd && l_tsd->size == sizeof(uint256_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_min_owners_num); 0; }) : 1;
}
int dap_chain_datum_decree_get_stake_tx_hash(dap_chain_datum_decree_t *a_decree, dap_hash_fast_t *a_tx_hash)
int dap_chain_datum_decree_get_hash(dap_chain_datum_decree_t *a_decree, dap_hash_fast_t *a_tx_hash)
{
if(!a_decree || !a_tx_hash){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_tx_hash); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_tx_hash, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH);
return l_tsd && l_tsd->size == sizeof(dap_hash_fast_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_tx_hash); 0; }) : 1;
}
int dap_chain_datum_decree_get_stake_value(dap_chain_datum_decree_t *a_decree, uint256_t *a_stake_value)
{
if(!a_decree || !a_stake_value){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_stake_value); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_stake_value, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE);
return l_tsd && l_tsd->size == sizeof(uint256_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_stake_value); 0; }) : 1;
}
int dap_chain_datum_decree_get_stake_signing_addr(dap_chain_datum_decree_t *a_decree, dap_chain_addr_t *a_signing_addr)
{
if(!a_decree || !a_signing_addr){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_signing_addr); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_signing_addr, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR);
return l_tsd && l_tsd->size == sizeof(dap_chain_addr_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_signing_addr); 0; }) : 1;
}
int dap_chain_datum_decree_get_stake_signer_node_addr(dap_chain_datum_decree_t *a_decree, dap_chain_node_addr_t *a_node_addr)
{
if(!a_decree || !a_node_addr){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNER_NODE_ADDR);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_node_addr); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_node_addr, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR);
return l_tsd && l_tsd->size == sizeof(dap_chain_node_addr_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_node_addr); 0; }) : 1;
}
int dap_chain_datum_decree_get_stake_min_value(dap_chain_datum_decree_t *a_decree, uint256_t *a_min_value)
{
if(!a_decree || !a_min_value){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_min_value); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_min_value, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE);
return l_tsd && l_tsd->size == sizeof(uint256_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_min_value); 0; }) : 1;
}
int dap_chain_datum_decree_get_stake_min_signers_count(dap_chain_datum_decree_t *a_decree, uint256_t *a_min_signers_count)
{
if(!a_decree || !a_min_signers_count){
log_it(L_CRITICAL, "Invalid arguments");
return -1;
}
dap_tsd_t* l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT);
return l_tsd ? ({ _dap_tsd_get_scalar(l_tsd, a_min_signers_count); 0; }) : 1;
dap_return_val_if_fail(a_decree && a_min_signers_count, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT);
return l_tsd && l_tsd->size == sizeof(uint256_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_min_signers_count); 0; }) : 1;
}
void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree_t *a_decree, size_t a_decree_size, const char *a_hash_out_type) {
int dap_chain_datum_decree_get_action(dap_chain_datum_decree_t *a_decree, uint8_t *a_action)
{
dap_return_val_if_fail(a_decree && a_action, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_ACTION);
return l_tsd && l_tsd->size == sizeof(uint8_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_action); 0; }) : 1;
}
int dap_chain_datum_decree_get_signature_type(dap_chain_datum_decree_t *a_decree, uint32_t *a_signature_type)
{
dap_return_val_if_fail(a_decree && a_signature_type, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGNATURE_TYPE);
return l_tsd && l_tsd->size == sizeof(uint32_t) ? ({ _dap_tsd_get_scalar(l_tsd, a_signature_type); 0; }) : 1;
}
int dap_chain_datum_decree_get_ban_addr(dap_chain_datum_decree_t *a_decree, const char **a_addr)
{
dap_return_val_if_fail(a_decree && a_addr, -1);
dap_tsd_t *l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST);
if (!l_tsd)
l_tsd = dap_tsd_find(a_decree->data_n_signs, a_decree->header.data_size, DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING);
return l_tsd ? ({ *a_addr = dap_tsd_get_string_const(l_tsd); !dap_strcmp(*a_addr, DAP_TSD_CORRUPTED_STRING); }) : 1;
}
void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree_t *a_decree, size_t a_decree_size, const char *a_hash_out_type)
{
char *l_type_str = "";
switch(a_decree->header.type)
{
......@@ -193,7 +183,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
}
uint256_t l_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_value);
char *l_value_str = dap_uint256_to_char(l_value, NULL);
const char *l_value_str = dap_uint256_to_char(l_value, NULL);
dap_string_append_printf(a_str_out, "\tValue: %s\n", l_value_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN:
......@@ -205,7 +195,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
}
uint256_t l_fee_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_fee_value);
char *l_fee_value_str = dap_uint256_to_char(l_fee_value, NULL);
const char *l_fee_value_str = dap_uint256_to_char(l_fee_value, NULL);
dap_string_append_printf(a_str_out, "\tFee: %s\n", l_fee_value_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER:
......@@ -220,13 +210,13 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
dap_string_append_printf(a_str_out, "\tOwner fingerprint: %s\n", l_owner_pkey_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
if (l_tsd->size > sizeof(uint256_t)){
if (l_tsd->size != sizeof(uint32_t)){
dap_string_append_printf(a_str_out, "\tOwner min: <WRONG SIZE>\n");
break;
}
uint256_t l_owner_min = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_owner_min);
char *l_owner_min_str = dap_uint256_to_char(l_owner_min, NULL);
const char *l_owner_min_str = dap_uint256_to_char(l_owner_min, NULL);
dap_string_append_printf(a_str_out, "\tOwner min: %s\n", l_owner_min_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET:
......@@ -238,9 +228,9 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
_dap_tsd_get_scalar(l_tsd, &l_addr_fee_wallet);*/ _dap_tsd_get_object(l_tsd, dap_chain_addr_t);
dap_string_append_printf(a_str_out, "\tWallet for fee: %s\n", dap_chain_addr_to_str(l_addr_fee_wallet));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH:
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH:
if (l_tsd->size > sizeof(dap_hash_fast_t)) {
dap_string_append_printf(a_str_out, "\tStake tx: <WRONG SIZE>\n");
dap_string_append_printf(a_str_out, "\tHash: <WRONG SIZE>\n");
break;
}
dap_hash_fast_t *l_stake_tx = /*{ };
......@@ -248,7 +238,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
const char *l_stake_tx_hash = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(l_stake_tx)
: dap_chain_hash_fast_to_str_static(l_stake_tx);
dap_string_append_printf(a_str_out, "\tStake tx: %s\n", l_stake_tx_hash);
dap_string_append_printf(a_str_out, "\tHash: %s\n", l_stake_tx_hash);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE:
if (l_tsd->size > sizeof(uint256_t)){
......@@ -257,7 +247,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
}
uint256_t l_stake_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_stake_value);
char *l_stake_value_str = dap_uint256_to_char(l_stake_value, NULL);
const char *l_stake_value_str = dap_uint256_to_char(l_stake_value, NULL);
dap_string_append_printf(a_str_out, "\tStake value: %s\n", l_stake_value_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR:
......@@ -274,7 +264,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
: dap_chain_hash_fast_to_str_static(&l_pkey_signing);
dap_string_append_printf(a_str_out, "\tSigning pkey fingerprint: %s\n", l_pkey_signing_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNER_NODE_ADDR:
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR:
if(l_tsd->size > sizeof(dap_chain_node_addr_t)){
dap_string_append_printf(a_str_out, "\tNode addr: <WRONG SIZE>\n");
break;
......@@ -290,7 +280,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
}
uint256_t l_min_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_min_value);
char *l_min_value_str = dap_uint256_to_char(l_min_value, NULL);
const char *l_min_value_str = dap_uint256_to_char(l_min_value, NULL);
dap_string_append_printf(a_str_out, "\tMin value: %s\n", l_min_value_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT:
......@@ -300,13 +290,32 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
}
uint256_t l_min_signers_count = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_min_signers_count);
char *l_min_signers_count_str = dap_uint256_to_char(l_min_signers_count, NULL);
const char *l_min_signers_count_str = dap_uint256_to_char(l_min_signers_count, NULL);
dap_string_append_printf(a_str_out, "\tMin signers count: %s\n", l_min_signers_count_str);
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST:
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR: {
dap_string_append_printf(a_str_out, "\tNode address: %s\n", dap_tsd_get_string(l_tsd));
} break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING:
dap_string_append_printf(a_str_out, "\tHost address: %s\n", dap_tsd_get_string(l_tsd));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_ACTION:
if (l_tsd->size != sizeof(uint8_t)){
dap_string_append_printf(a_str_out, "\tAction: <WRONG SIZE>\n");
break;
}
uint8_t l_action = 0;
_dap_tsd_get_scalar(l_tsd, &l_action);
dap_string_append_printf(a_str_out, "\tAction: %s\n", l_action ? "add (enable)" : "delete (disable)");
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGNATURE_TYPE:
if (l_tsd->size != sizeof(uint32_t)){
dap_string_append_printf(a_str_out, "\tSignature type: <WRONG SIZE>\n");
break;
}
uint32_t l_type = 0;
_dap_tsd_get_scalar(l_tsd, &l_type);
dap_sign_type_t l_sign_type = { .type = l_type };
dap_string_append_printf(a_str_out, "\tSignature type: %s\n", dap_sign_type_to_str(l_sign_type));
break;
default:
dap_string_append_printf(a_str_out, "\t<UNKNOWN_TYPE_TSD_SECTION>\n");
break;
......@@ -349,30 +358,263 @@ void dap_chain_datum_decree_certs_dump(dap_string_t * a_str_out, byte_t * a_sign
}
}
dap_chain_datum_decree_t* dap_chain_datum_decree_sign_in_cycle(dap_cert_t ** a_certs, dap_chain_datum_decree_t *a_datum_decree,
void dap_chain_datum_decree_dump_json(json_object *a_json_out, dap_chain_datum_decree_t *a_decree, size_t a_decree_size, const char *a_hash_out_type)
{
char *l_type_str = "";
char l_tmp_buff[70]={0};
switch(a_decree->header.type)
{
case DAP_CHAIN_DATUM_DECREE_TYPE_COMMON:
l_type_str = "DECREE_TYPE_COMMON";
break;
case DAP_CHAIN_DATUM_DECREE_TYPE_SERVICE:
l_type_str = "DECREE_TYPE_SERVICE";
break;
default:
l_type_str = "DECREE_TYPE_UNKNOWN";
}
json_object_object_add(a_json_out, "type", json_object_new_string(l_type_str));
const char *l_subtype_str = dap_chain_datum_decree_subtype_to_str(a_decree->header.sub_type);
json_object_object_add(a_json_out, "subtype", json_object_new_string(l_subtype_str));
json_object_object_add(a_json_out, "TSD", json_object_new_string(""));
for (size_t l_offset = 0; l_offset < a_decree->header.data_size;) {
dap_tsd_t *l_tsd = (dap_tsd_t *)((byte_t*)a_decree->data_n_signs + l_offset);
l_offset += dap_tsd_size(l_tsd);
switch(l_tsd->type) {
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE:
if (l_tsd->size > sizeof(uint256_t)){
json_object_object_add(a_json_out, "Value", json_object_new_string("WRONG SIZE"));
break;
}
uint256_t l_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_value);
const char *l_value_str = dap_uint256_to_char(l_value, NULL);
json_object_object_add(a_json_out, "Value", json_object_new_string(l_value_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN:
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE:
if (l_tsd->size > sizeof(uint256_t)){
json_object_object_add(a_json_out, "Fee", json_object_new_string("WRONG SIZE"));
break;
}
uint256_t l_fee_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_fee_value);
const char *l_fee_value_str = dap_uint256_to_char(l_fee_value, NULL);
json_object_object_add(a_json_out, "Fee", json_object_new_string(l_fee_value_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER:
if (l_tsd->size < sizeof(dap_pkey_t)) {
json_object_object_add(a_json_out, "Owner fingerprint", json_object_new_string("WRONG SIZE"));
break;
}
dap_pkey_t *l_owner_pkey = /*DAP_NEW_STACK_SIZE(dap_pkey_t, l_tsd->size);
memcpy(l_owner_pkey, l_tsd->data, l_tsd->size);*/ _dap_tsd_get_object(l_tsd, dap_pkey_t);
char *l_owner_pkey_str;
dap_get_data_hash_str_static(l_owner_pkey->pkey, l_owner_pkey->header.size, l_owner_pkey_str);
json_object_object_add(a_json_out, "Owner fingerprint", json_object_new_string(l_owner_pkey_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
if (l_tsd->size > sizeof(uint256_t)){
json_object_object_add(a_json_out, "Owner min", json_object_new_string("WRONG SIZE"));
break;
}
uint256_t l_owner_min = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_owner_min);
const char *l_owner_min_str = dap_uint256_to_char(l_owner_min, NULL);
json_object_object_add(a_json_out, "Owner min", json_object_new_string(l_owner_min_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET:
if (l_tsd->size > sizeof(dap_chain_addr_t)) {
json_object_object_add(a_json_out, "Wallet for fee", json_object_new_string("WRONG SIZE"));
break;
}
dap_chain_addr_t *l_addr_fee_wallet = /*{ };
_dap_tsd_get_scalar(l_tsd, &l_addr_fee_wallet);*/ _dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(a_json_out, "Wallet for fee", json_object_new_string(dap_chain_addr_to_str(l_addr_fee_wallet)));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH:
if (l_tsd->size > sizeof(dap_hash_fast_t)) {
json_object_object_add(a_json_out, "Stake tx", json_object_new_string("WRONG SIZE"));
break;
}
dap_hash_fast_t *l_stake_tx = /*{ };
_dap_tsd_get_scalar(l_tsd, &l_stake_tx);*/ _dap_tsd_get_object(l_tsd, dap_hash_fast_t);
const char *l_stake_tx_hash = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(l_stake_tx)
: dap_chain_hash_fast_to_str_static(l_stake_tx);
json_object_object_add(a_json_out, "Stake tx", json_object_new_string(l_stake_tx_hash));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE:
if (l_tsd->size > sizeof(uint256_t)){
json_object_object_add(a_json_out, "Stake value", json_object_new_string("WRONG SIZE"));
break;
}
uint256_t l_stake_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_stake_value);
const char *l_stake_value_str = dap_uint256_to_char(l_stake_value, NULL);
json_object_object_add(a_json_out, "Stake value", json_object_new_string(l_stake_value_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR:
if (l_tsd->size > sizeof(dap_chain_addr_t)) {
json_object_object_add(a_json_out, "Signing addr", json_object_new_string("WRONG SIZE"));
break;
}
dap_chain_addr_t *l_stake_addr_signing = /*{ };
_dap_tsd_get_scalar(l_tsd, &l_stake_addr_signing);*/ _dap_tsd_get_object(l_tsd, dap_chain_addr_t);
json_object_object_add(a_json_out, "Signing addr", json_object_new_string(dap_chain_addr_to_str(l_stake_addr_signing)));
dap_chain_hash_fast_t l_pkey_signing = l_stake_addr_signing->data.hash_fast;
const char *l_pkey_signing_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_pkey_signing)
: dap_chain_hash_fast_to_str_static(&l_pkey_signing);
json_object_object_add(a_json_out, "Signing pkey fingerprint", json_object_new_string(l_pkey_signing_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR:
if(l_tsd->size > sizeof(dap_chain_node_addr_t)){
json_object_object_add(a_json_out, "Node addr", json_object_new_string("WRONG SIZE"));
break;
}
dap_chain_node_addr_t *l_node_addr = _dap_tsd_get_object(l_tsd, dap_chain_node_addr_t);
sprintf(l_tmp_buff, NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS(l_node_addr));
json_object_object_add(a_json_out, "Node addr", json_object_new_string(l_tmp_buff));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE:
if (l_tsd->size > sizeof(uint256_t)) {
json_object_object_add(a_json_out, "Min value", json_object_new_string("WRONG SIZE"));
break;
}
uint256_t l_min_value = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_min_value);
const char *l_min_value_str = dap_uint256_to_char(l_min_value, NULL);
json_object_object_add(a_json_out, "Min value", json_object_new_string(l_min_value_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT:
if (l_tsd->size > sizeof(uint256_t)) {
json_object_object_add(a_json_out, "Min signers count", json_object_new_string("WRONG SIZE"));
break;
}
uint256_t l_min_signers_count = uint256_0;
_dap_tsd_get_scalar(l_tsd, &l_min_signers_count);
const char *l_min_signers_count_str = dap_uint256_to_char(l_min_signers_count, NULL);
json_object_object_add(a_json_out, "Min signers count", json_object_new_string(l_min_signers_count_str));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST:
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING:
json_object_object_add(a_json_out, "Host address", json_object_new_string(dap_tsd_get_string(l_tsd)));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_ACTION:
if (l_tsd->size != sizeof(uint8_t)) {
json_object_object_add(a_json_out, "Action", json_object_new_string("WRONG SIZE"));
break;
}
uint8_t l_action = 0;
_dap_tsd_get_scalar(l_tsd, &l_action);
json_object_object_add(a_json_out, "tAction", l_action ?
json_object_new_string("add (enable)") : json_object_new_string("delete (disable)"));
break;
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGNATURE_TYPE:
if (l_tsd->size != sizeof(uint32_t)) {
json_object_object_add(a_json_out, "Signature type", json_object_new_string("WRONG SIZE"));
break;
}
uint32_t l_type = 0;
_dap_tsd_get_scalar(l_tsd, &l_type);
dap_sign_type_t l_sign_type = { .type = l_type };
json_object_object_add(a_json_out, "Signature type", json_object_new_string(dap_sign_type_to_str(l_sign_type)));
break;
default:
json_object_object_add(a_json_out, "UNKNOWN_TYPE_TSD_SECTION", json_object_new_string(""));
break;
}
}
dap_chain_datum_decree_certs_dump_json(a_json_out, a_decree->data_n_signs + a_decree->header.data_size,
a_decree->header.signs_size, a_hash_out_type);
}
void dap_chain_datum_decree_certs_dump_json(json_object * a_json_out, byte_t * a_signs, size_t a_certs_size, const char *a_hash_out_type)
{
json_object_object_add(a_json_out, "signatures", json_object_new_string(""));
if (!a_certs_size) {
json_object_object_add(a_json_out, "Cert status", json_object_new_string("NONE"));
return;
}
json_object* json_arr_certs_out = json_object_new_array();
size_t l_offset = 0;
for (int i = 1; l_offset < (a_certs_size); i++) {
json_object* json_obj_sign = json_object_new_object();
dap_sign_t *l_sign = (dap_sign_t *) (a_signs + l_offset);
l_offset += dap_sign_get_size(l_sign);
if (l_sign->header.sign_size == 0) {
json_object_object_add(json_obj_sign, "sign status", json_object_new_string("CORRUPTED - 0 size signature"));
json_object_array_add(json_arr_certs_out, json_obj_sign);
continue;
}
dap_chain_hash_fast_t l_pkey_hash = {0};
if (dap_sign_get_pkey_hash(l_sign, &l_pkey_hash) == false) {
json_object_object_add(json_obj_sign, "sign status", json_object_new_string("CORRUPTED - can't calc hash"));
json_object_array_add(json_arr_certs_out, json_obj_sign);
continue;
}
const char *l_hash_str = dap_strcmp(a_hash_out_type, "hex")
? dap_enc_base58_encode_hash_to_str_static(&l_pkey_hash)
: dap_chain_hash_fast_to_str_static(&l_pkey_hash);
json_object_object_add(json_obj_sign, "sign #", json_object_new_uint64(i));
json_object_object_add(json_obj_sign, "hash", json_object_new_string(l_hash_str));
json_object_object_add(json_obj_sign, "type", json_object_new_string(dap_sign_type_to_str(l_sign->header.type)));
json_object_object_add(json_obj_sign, "sign size", json_object_new_uint64(l_sign->header.sign_size));
json_object_array_add(json_arr_certs_out, json_obj_sign);
}
json_object_object_add(a_json_out,"SIGNS", json_arr_certs_out);
}
dap_chain_datum_decree_t *dap_chain_datum_decree_new(dap_chain_net_id_t a_net_id, dap_chain_id_t a_chain_id,
dap_chain_cell_id_t a_cell_id, size_t a_total_tsd_size)
{
dap_chain_datum_decree_t *l_decree = NULL;
DAP_NEW_Z_SIZE_RET_VAL(l_decree, dap_chain_datum_decree_t, sizeof(dap_chain_datum_decree_t) + a_total_tsd_size, NULL, NULL);
l_decree->decree_version = DAP_CHAIN_DATUM_DECREE_VERSION;
l_decree->header.ts_created = dap_time_now();
l_decree->header.type = DAP_CHAIN_DATUM_DECREE_TYPE_COMMON;
l_decree->header.common_decree_params.net_id = a_net_id;
l_decree->header.common_decree_params.chain_id = a_chain_id;
l_decree->header.common_decree_params.cell_id = a_cell_id;
l_decree->header.data_size = a_total_tsd_size;
return l_decree;
}
dap_chain_datum_decree_t *dap_chain_datum_decree_sign_in_cycle(dap_cert_t **a_certs, dap_chain_datum_decree_t *a_datum_decree,
size_t a_certs_count, size_t *a_total_sign_count)
{
size_t l_cur_sign_offset = a_datum_decree->header.data_size + a_datum_decree->header.signs_size;
size_t l_total_signs_size = a_datum_decree->header.signs_size, l_total_sign_count = 0;
for(size_t i = 0; i < a_certs_count; i++)
{
dap_sign_t * l_sign = dap_cert_sign(a_certs[i], a_datum_decree,
for(size_t i = 0; i < a_certs_count; i++) {
dap_sign_t * l_sign = dap_cert_sign(a_certs[i], a_datum_decree,
sizeof(dap_chain_datum_decree_t) + a_datum_decree->header.data_size, 0);
if (l_sign) {
size_t l_sign_size = dap_sign_get_size(l_sign);
a_datum_decree = DAP_REALLOC(a_datum_decree, sizeof(dap_chain_datum_decree_t) + l_cur_sign_offset + l_sign_size);
memcpy((byte_t*)a_datum_decree->data_n_signs + l_cur_sign_offset, l_sign, l_sign_size);
l_total_signs_size += l_sign_size;
l_cur_sign_offset += l_sign_size;
a_datum_decree->header.signs_size = l_total_signs_size;
if (!l_sign) {
log_it(L_ERROR, "Decree signing failed");
DAP_DELETE(a_datum_decree);
return NULL;
}
size_t l_sign_size = dap_sign_get_size(l_sign);
a_datum_decree = DAP_REALLOC(a_datum_decree, sizeof(dap_chain_datum_decree_t) + l_cur_sign_offset + l_sign_size);
if (!a_datum_decree) {
log_it(L_CRITICAL, "%s", g_error_memory_alloc);
DAP_DELETE(l_sign);
log_it(L_DEBUG,"<-- Signed with '%s'", a_certs[i]->name);
l_total_sign_count++;
return NULL;
}
memcpy(a_datum_decree->data_n_signs + l_cur_sign_offset, l_sign, l_sign_size);
DAP_DELETE(l_sign);
l_total_signs_size += l_sign_size;
l_cur_sign_offset += l_sign_size;
a_datum_decree->header.signs_size = l_total_signs_size;
log_it(L_DEBUG,"<-- Signed with '%s'", a_certs[i]->name);
l_total_sign_count++;
}
*a_total_sign_count = l_total_sign_count;
if (a_total_sign_count)
*a_total_sign_count = l_total_sign_count;
return a_datum_decree;
}
modules/common/dap_chain_datum_tx_items.c
View file @ 504a55ab
......@@ -34,6 +34,7 @@
#include "dap_chain_datum_tx_items.h"
#include "dap_chain_datum_tx_voting.h"
#define LOG_TAG "dap_chain_datum_tx_items"
static size_t dap_chain_tx_in_get_size(const dap_chain_tx_in_t *a_item)
{
......@@ -696,3 +697,152 @@ uint8_t *dap_chain_datum_tx_out_get_by_out_idx(dap_chain_datum_tx_t *a_tx, int a
return l_ret;
}
void dap_chain_datum_tx_group_items_free( dap_chain_datum_tx_item_groups_t *a_items_groups)
{
if (a_items_groups->items_in) dap_list_free(a_items_groups->items_in);
if (a_items_groups->items_in_cond) dap_list_free(a_items_groups->items_in_cond);
if (a_items_groups->items_in_reward) dap_list_free(a_items_groups->items_in_reward);
if (a_items_groups->items_sig) dap_list_free(a_items_groups->items_sig);
if (a_items_groups->items_out) dap_list_free(a_items_groups->items_out);
if (a_items_groups->items_out_ext) dap_list_free(a_items_groups->items_out_ext);
if (a_items_groups->items_out_cond) dap_list_free(a_items_groups->items_out_cond);
if (a_items_groups->items_out_cond_srv_fee) dap_list_free(a_items_groups->items_out_cond_srv_fee);
if (a_items_groups->items_out_cond_srv_pay) dap_list_free(a_items_groups->items_out_cond_srv_pay);
if (a_items_groups->items_out_cond_srv_xchange) dap_list_free(a_items_groups->items_out_cond_srv_xchange);
if (a_items_groups->items_out_cond_srv_stake_pos_delegate) dap_list_free(a_items_groups->items_out_cond_srv_stake_pos_delegate);
if (a_items_groups->items_out_cond_srv_stake_lock) dap_list_free(a_items_groups->items_out_cond_srv_stake_lock);
if (a_items_groups->items_in_ems) dap_list_free(a_items_groups->items_in_ems);
if (a_items_groups->items_vote) dap_list_free(a_items_groups->items_vote);
if (a_items_groups->items_voting) dap_list_free(a_items_groups->items_voting);
if (a_items_groups->items_tsd) dap_list_free(a_items_groups->items_tsd);
if (a_items_groups->items_pkey) dap_list_free(a_items_groups->items_pkey);
if (a_items_groups->items_receipt) dap_list_free(a_items_groups->items_receipt);
if (a_items_groups->items_unknown) dap_list_free(a_items_groups->items_unknown);
if (a_items_groups->items_out_old) dap_list_free(a_items_groups->items_out_old);
if (a_items_groups->items_out_cond_unknonwn) dap_list_free(a_items_groups->items_out_cond_unknonwn);
if (a_items_groups->items_out_cond_undefined) dap_list_free(a_items_groups->items_out_cond_undefined);
if (a_items_groups->items_out_all) dap_list_free(a_items_groups->items_out_all);
if (a_items_groups->items_in_all) dap_list_free(a_items_groups->items_in_all);
}
#define DAP_LIST_SAPPEND(X, Y) X = dap_list_append(X,Y)
bool dap_chain_datum_tx_group_items(dap_chain_datum_tx_t *a_tx, dap_chain_datum_tx_item_groups_t *a_res_group)
{
if(!a_tx || !a_res_group)
return NULL;
uint32_t l_tx_items_pos = 0, l_tx_items_size = a_tx->header.tx_items_size;
int l_item_idx = 0;
while (l_tx_items_pos < l_tx_items_size) {
uint8_t *l_item = a_tx->tx_items + l_tx_items_pos;
int l_item_size = dap_chain_datum_item_tx_get_size(l_item);
if(!l_item_size)
return false;
dap_chain_tx_item_type_t l_type = dap_chain_datum_tx_item_get_type(l_item);
switch (l_type)
{
case TX_ITEM_TYPE_IN:
DAP_LIST_SAPPEND(a_res_group->items_in, l_item);
DAP_LIST_SAPPEND(a_res_group->items_in_all, l_item);
break;
case TX_ITEM_TYPE_IN_COND:
DAP_LIST_SAPPEND(a_res_group->items_in_cond, l_item);
DAP_LIST_SAPPEND(a_res_group->items_in_all, l_item);
break;
case TX_ITEM_TYPE_IN_REWARD:
DAP_LIST_SAPPEND(a_res_group->items_in_reward, l_item);
DAP_LIST_SAPPEND(a_res_group->items_in_all, l_item);
break;
case TX_ITEM_TYPE_IN_EMS:
DAP_LIST_SAPPEND(a_res_group->items_in_ems, l_item);
DAP_LIST_SAPPEND(a_res_group->items_in_all, l_item);
break;
case TX_ITEM_TYPE_OUT_OLD:
DAP_LIST_SAPPEND(a_res_group->items_out_old, l_item);
DAP_LIST_SAPPEND(a_res_group->items_out_all, l_item);
break;
case TX_ITEM_TYPE_OUT_EXT:
DAP_LIST_SAPPEND(a_res_group->items_out_ext, l_item);
DAP_LIST_SAPPEND(a_res_group->items_out_all, l_item);
break;
case TX_ITEM_TYPE_OUT:
DAP_LIST_SAPPEND(a_res_group->items_out, l_item);
DAP_LIST_SAPPEND(a_res_group->items_out_all, l_item);
break;
case TX_ITEM_TYPE_OUT_COND: {
switch ( ((dap_chain_tx_out_cond_t *)l_item)->header.subtype )
{
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_UNDEFINED:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_undefined, l_item);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_srv_pay, l_item);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_srv_xchange, l_item);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_srv_stake_pos_delegate, l_item);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_FEE:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_srv_fee, l_item);
break;
case DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_LOCK:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_srv_stake_lock, l_item);
break;
default:
DAP_LIST_SAPPEND(a_res_group->items_out_cond_unknonwn, l_item);
break;
}
DAP_LIST_SAPPEND(a_res_group->items_out_cond, l_item);
DAP_LIST_SAPPEND(a_res_group->items_out_all, l_item);
}
break;
case TX_ITEM_TYPE_PKEY:
DAP_LIST_SAPPEND(a_res_group->items_pkey, l_item);
break;
case TX_ITEM_TYPE_SIG:
DAP_LIST_SAPPEND(a_res_group->items_sig, l_item);
break;
case TX_ITEM_TYPE_RECEIPT:
DAP_LIST_SAPPEND(a_res_group->items_receipt, l_item);
break;
case TX_ITEM_TYPE_TSD:
DAP_LIST_SAPPEND(a_res_group->items_tsd, l_item);
break;
case TX_ITEM_TYPE_VOTING:
DAP_LIST_SAPPEND(a_res_group->items_voting, l_item);
break;
case TX_ITEM_TYPE_VOTE:
DAP_LIST_SAPPEND(a_res_group->items_vote, l_item);
break;
default:
DAP_LIST_SAPPEND(a_res_group->items_unknown, l_item);
}
l_tx_items_pos += l_item_size;
l_item_idx++;
}
return true;
}
modules/common/include/dap_chain_common.h
View file @ 504a55ab
......@@ -30,10 +30,8 @@
#include "dap_math_ops.h"
#include "dap_math_convert.h"
#include "dap_enc_key.h"
#include "dap_pkey.h"
#include "dap_sign.h"
#include "dap_hash.h"
#include "json.h"
#include "dap_strfuncs.h"
#define DAP_CHAIN_ADDR_VERSION_CURRENT 1
......@@ -200,7 +198,7 @@ extern "C" {
size_t dap_chain_hash_slow_to_str(dap_chain_hash_slow_t * a_hash, char * a_str, size_t a_str_max);
char* dap_chain_addr_to_str(const dap_chain_addr_t *a_addr);
const char *dap_chain_addr_to_str(const dap_chain_addr_t *a_addr);
dap_chain_addr_t* dap_chain_addr_from_str(const char *str);
bool dap_chain_addr_is_blank(const dap_chain_addr_t *a_addr);
......
modules/common/include/dap_chain_datum.h
View file @ 504a55ab
......@@ -25,11 +25,9 @@
#pragma once
#include <stdint.h>
#include "dap_common.h"
#include "dap_math_ops.h"
#include "dap_chain_common.h"
#include "dap_chain_datum_tx.h"
#include "dap_chain_datum_token.h"
#include "json.h"
#define DAP_CHAIN_DATUM_VERSION 0x00
......@@ -162,4 +160,11 @@ bool dap_chain_datum_dump_tx(dap_chain_datum_tx_t *a_datum,
const char *a_hash_out_type,
dap_hash_fast_t *a_tx_hash,
dap_chain_net_id_t a_net_id);
bool dap_chain_datum_dump_tx_json(dap_chain_datum_tx_t *a_datum,
const char *a_ticker,
json_object* json_obj_out,
const char *a_hash_out_type,
dap_hash_fast_t *a_tx_hash,
dap_chain_net_id_t a_net_id);
json_object * dap_chain_datum_to_json(dap_chain_datum_t* a_datum);
void dap_chain_datum_dump_json(json_object *a_obj_out, dap_chain_datum_t *a_datum, const char *a_hash_out_type, dap_chain_net_id_t a_net_id);
modules/common/include/dap_chain_datum_anchor.h
View file @ 504a55ab
......@@ -51,3 +51,5 @@ DAP_STATIC_INLINE size_t dap_chain_datum_anchor_get_size(dap_chain_datum_anchor_
int dap_chain_datum_anchor_get_hash_from_data(dap_chain_datum_anchor_t* a_anchor, dap_hash_fast_t * l_out_hash);
void dap_chain_datum_anchor_certs_dump(dap_string_t * a_str_out, byte_t * a_signs,
size_t a_certs_size, const char *a_hash_out_type);
void dap_chain_datum_anchor_certs_dump_json(json_object * a_json_out, byte_t * a_signs, size_t a_certs_size, const char *a_hash_out_type);
modules/common/include/dap_chain_datum_decree.h
View file @ 504a55ab
......@@ -26,7 +26,6 @@
#include "dap_math_ops.h"
#include "dap_time.h"
#include "dap_list.h"
#include "dap_tsd.h"
#include "dap_cert.h"
#include <stdint.h>
......@@ -73,6 +72,9 @@ DAP_STATIC_INLINE size_t dap_chain_datum_decree_get_size(dap_chain_datum_decree_
#define DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_BAN 0x0009
#define DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_UNBAN 0x000A
#define DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_REWARD 0x000B
#define DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_MAX_WEIGHT 0x000C
#define DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_EMERGENCY_VALIDATORS 0x000D
#define DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_CHECK_SIGNS_STRUCTURE 0x000E
// DECREE TSD types
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE 0x0100
......@@ -81,14 +83,16 @@ DAP_STATIC_INLINE size_t dap_chain_datum_decree_get_size(dap_chain_datum_decree_
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER 0x0103
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER 0x0104
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET 0x0106
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH 0x0107
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH 0x0107
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE 0x0108
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR 0x0109
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNER_NODE_ADDR 0x0110
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR 0x0110
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE 0x0111
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT 0x0112
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST 0x0113
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR 0x0115
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING 0x0115
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_ACTION 0x010A
#define DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGNATURE_TYPE 0x010B
DAP_STATIC_INLINE const char *dap_chain_datum_decree_subtype_to_str(uint16_t a_decree_subtype)
{
......@@ -113,6 +117,12 @@ DAP_STATIC_INLINE const char *dap_chain_datum_decree_subtype_to_str(uint16_t a_d
return "DECREE_COMMON_SUBTYPE_UNBAN";
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_REWARD:
return "DECREE_COMMON_SUBTYPE_REWARD";
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_MAX_WEIGHT:
return "DECREE_COMMON_SUBTYPE_VALIDATOR_MAX_WEIGHT";
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_EMERGENCY_VALIDATORS:
return "DECREE_COMMON_SUBTYPE_EMERGENCY_VALIDATORS";
case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_CHECK_SIGNS_STRUCTURE:
return "DECREE_COMMON_SUBTYPE_CHECK_SIGNS_STRUCTURE";
default:
return "DECREE_SUBTYPE_UNKNOWN";
}
......@@ -120,39 +130,45 @@ DAP_STATIC_INLINE const char *dap_chain_datum_decree_subtype_to_str(uint16_t a_d
DAP_STATIC_INLINE const char *dap_chain_datum_decree_tsd_type_to_str(uint16_t a_decree_tsd_type) {
switch (a_decree_tsd_type) {
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_TX_HASH";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNER_NODE_ADDR:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNER_NODE_ADDR";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR";
default:
return "DECREE_TSD_TYPE_UNKNOWN";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_ACTION:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_ACTION";
case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGNATURE_TYPE:
return "DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGNATURE_TYPE";
default:
return "DECREE_TSD_TYPE_UNKNOWN";
}
}
dap_chain_datum_decree_t *dap_chain_datum_decree_new(dap_chain_net_id_t a_net_id, dap_chain_id_t a_chain_id,
dap_chain_cell_id_t a_cell_id, size_t a_total_tsd_size);
/**
* @brief dap_chain_datum_decree_get_signs
* @param decree pointer to decree
......@@ -192,7 +208,7 @@ dap_list_t *dap_chain_datum_decree_get_owners(dap_chain_datum_decree_t *a_decree
* @param a_owners_num pointer to minimum number of owners buffer
* @return result code. 0 - success
*/
int dap_chain_datum_decree_get_min_owners(dap_chain_datum_decree_t *a_decree, uint16_t *a_min_owners_num);
int dap_chain_datum_decree_get_min_owners(dap_chain_datum_decree_t *a_decree, uint256_t *a_min_owners_num);
/**
* @brief dap_chain_datum_decree_get_tx_hash get stake tx hash
......@@ -200,7 +216,7 @@ int dap_chain_datum_decree_get_min_owners(dap_chain_datum_decree_t *a_decree, ui
* @param a_tx_hash pointer to tx hash buffer
* @return result code. 0 - success
*/
int dap_chain_datum_decree_get_stake_tx_hash(dap_chain_datum_decree_t *a_decree, dap_hash_fast_t *a_tx_hash);
int dap_chain_datum_decree_get_hash(dap_chain_datum_decree_t *a_decree, dap_hash_fast_t *a_tx_hash);
/**
* @brief dap_chain_datum_decree_get_stake_value get stake value
......@@ -250,6 +266,9 @@ int dap_chain_datum_decree_get_stake_min_value(dap_chain_datum_decree_t *a_decre
* @return result code. 0 - success
*/
int dap_chain_datum_decree_get_stake_min_signers_count(dap_chain_datum_decree_t *a_decree, uint256_t *a_min_signers_count);
int dap_chain_datum_decree_get_action(dap_chain_datum_decree_t *a_decree, uint8_t *a_action);
int dap_chain_datum_decree_get_signature_type(dap_chain_datum_decree_t *a_decree, uint32_t *a_signature_type);
int dap_chain_datum_decree_get_ban_addr(dap_chain_datum_decree_t *a_decree, const char **a_addr);
/**
* @breif dap_chain_datum_decree_dump Dump information about decree
......@@ -260,6 +279,15 @@ int dap_chain_datum_decree_get_stake_min_signers_count(dap_chain_datum_decree_t
*/
void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree_t *a_decree, size_t a_decree_size, const char *a_hash_out_type);
/**
* @breif dap_chain_datum_decree_dump Dump information about decree
* @param a_obj_out pointer to output json object
* @param a_decree pointer to decree
* @param a_decree_size size data
* @param a_hash_out_type
*/
void dap_chain_datum_decree_dump_json(json_object *a_obj_out, dap_chain_datum_decree_t *a_decree, size_t a_decree_size, const char *a_hash_out_type);
/**
* @brief dap_chain_datum_decree_certs_dump compose decree signatures output string
* @param a_str_out pointer to output text buffer
......@@ -268,6 +296,8 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
*/
void dap_chain_datum_decree_certs_dump(dap_string_t * a_str_out, byte_t * a_signs, size_t a_certs_size, const char *a_hash_out_type);
void dap_chain_datum_decree_certs_dump_json(json_object * a_json_out, byte_t * a_signs, size_t a_certs_size, const char *a_hash_out_type);
/**
* @brief dap_chain_datum_decree_sign_in_cycle
* sign data (datum_decree) by certificates (1 or more)
......
modules/common/include/dap_chain_datum_token.h
View file @ 504a55ab
......@@ -500,6 +500,22 @@ typedef struct dap_chain_datum_token_emission {
#define DAP_CHAIN_DATUM_EMISSION_TSD_TYPE_UNIQUE_ID 0x000F
#define DAP_CHAIN_DATUM_EMISSION_TSD_TYPE_BASE_TX_HASH 0x0010
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_STAKING "STAKING"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_STAKE_CROSSCHAIN "CONTRACT"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_STAKE_CROSSCHAINV2 "CONTRACT_NFT"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_HARVEST "HARVEST"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_ADDLIQ "ADDLIQ"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_EMSFIX "EMSFIX"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_BONUS "BONUS"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_STAKING_UNSTAKE_FINALIZATION "UNSTAKE"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_BRIDGE "BRIDGE"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_BRIDGE_TRANSFER "TO_WALLET"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_BRIDGE_COMMISSION_OLD "COMISSION"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_BRIDGE_COMMISSION "COMMISSION"
#define DAP_CHAIN_DATUM_TOKEN_EMISSION_SOURCE_SUBTYPE_BRIDGE_CROSSCHAIN "CROSSCHAIN"
extern const char *c_dap_chain_datum_token_emission_type_str[];
/// TDS op funcs
......
modules/common/include/dap_chain_datum_tx.h
View file @ 504a55ab
......@@ -27,7 +27,7 @@
#include "dap_enc_key.h"
#include "dap_chain_common.h"
#include "dap_time.h"
#include "json.h"
#include "dap_pkey.h"
/**
* @struct dap_chain_datum_tx
......@@ -153,6 +153,5 @@ dap_sign_t *dap_chain_datum_tx_get_sign(dap_chain_datum_tx_t *a_tx, int a_sign_n
*/
int dap_chain_datum_tx_verify_sign(dap_chain_datum_tx_t *a_tx);
//json_object *dap_chain_datum_tx_to_json(dap_chain_datum_tx_t *a_tx);
int dap_chain_datum_tx_get_fee_value (dap_chain_datum_tx_t *a_tx, uint256_t *a_value);