//---------------------------------------------------------------
bool generate_genesis_block(
block& bl
, std::string const & genesis_tx
, uint32_t nonce
)
{
//genesis block
bl = boost::value_initialized<block>();
account_public_address ac = boost::value_initialized<account_public_address>();
std::vector<size_t> sz;
construct_miner_tx(0, 0, 0, 0, 0, ac, bl.miner_tx); // zero fee in genesis
blobdata txb = tx_to_blob(bl.miner_tx);
std::string hex_tx_represent = string_tools::buff_to_hex_nodelimer(txb);
std::string genesis_coinbase_tx_hex = config::GENESIS_TX;
blobdata tx_bl;
string_tools::parse_hexstr_to_binbuff(genesis_coinbase_tx_hex, tx_bl);
bool r = parse_and_validate_tx_from_blob(tx_bl, bl.miner_tx);
CHECK_AND_ASSERT_MES(r, false, "failed to parse coinbase tx from hard coded blob");
bl.major_version = CURRENT_BLOCK_MAJOR_VERSION;
bl.minor_version = CURRENT_BLOCK_MINOR_VERSION;
bl.timestamp = 0;
bl.nonce = nonce;
miner::find_nonce_for_given_block(bl, 1, 0);
bl.invalidate_hashes();
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
bool wallet_rpc_server::on_clonetelepod(const wallet_rpc::COMMAND_RPC_CLONETELEPOD::request& req, wallet_rpc::COMMAND_RPC_CLONETELEPOD::response& res, epee::json_rpc::error& er, connection_context& cntx)
{
currency::transaction tx2 = AUTO_VAL_INIT(tx2);
//new destination account
currency::account_base acc2 = AUTO_VAL_INIT(acc2);
acc2.generate();
if (!build_transaction_from_telepod(req.tpd, acc2.get_keys().m_account_address, tx2, res.status))
{
LOG_ERROR("Failed to build_transaction_from_telepod(...)");
return true;
}
//send transaction to daemon
currency::COMMAND_RPC_SEND_RAW_TX::request req_send_raw;
req_send_raw.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx2));
currency::COMMAND_RPC_SEND_RAW_TX::response rsp_send_raw;
bool r = m_wallet.get_core_proxy()->call_COMMAND_RPC_SEND_RAW_TX(req_send_raw, rsp_send_raw);
if (!r || rsp_send_raw.status != CORE_RPC_STATUS_OK)
{
LOG_ERROR("Problem with construct_tx(....), blobl size os too big: " << get_object_blobsize(tx2));
res.status = "INTERNAL_ERROR";
return true;
}
res.tpd.basement_tx_id_hex = string_tools::pod_to_hex(currency::get_transaction_hash(tx2));
std::string acc2_buff = epee::serialization::store_t_to_binary(acc2);
res.tpd.account_keys_hex = string_tools::buff_to_hex_nodelimer(acc2_buff);
res.status = "OK";
LOG_PRINT_GREEN("TELEPOD ISSUED [" << currency::print_money(currency::get_outs_money_amount(tx2)) << "BBR, base_tx_id: ]" << currency::get_transaction_hash(tx2), LOG_LEVEL_0);
return true;
}
extern "C" uint64_t pNXT_submit_tx(currency::core *m_core,currency::simple_wallet *wallet,unsigned char *txbytes,int16_t size)
{
int i,j;
crypto::hash h;
uint64_t txid = 0;
blobdata txb,b;
transaction tx = AUTO_VAL_INIT(tx);
txin_to_key input_to_key = AUTO_VAL_INIT(input_to_key);
NOTIFY_NEW_TRANSACTIONS::request req;
currency_connection_context fake_context = AUTO_VAL_INIT(fake_context);
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
if ( m_core == 0 || wallet == 0 )
{
printf("pNXT_submit_tx missing m_core.%p or wallet.%p\n",m_core,wallet);
return(0);
}
tx.vin.clear();
tx.vout.clear();
tx.signatures.clear();
keypair txkey = keypair::generate();
add_tx_pub_key_to_extra(tx, txkey.pub);
if ( sizeof(input_to_key.k_image) != 32 )
{
printf("FATAL: expected sizeof(input_to_key.k_image) to be 32!\n");
return(0);
}
j = add_byte(&tx,&input_to_key,0,size&0xff);
j = add_byte(&tx,&input_to_key,j,(size>>8)&0xff);
for (i=0; i<size; i++)
j = add_byte(&tx,&input_to_key,j,txbytes[i]);
if ( j != 0 )
tx.vin.push_back(input_to_key);
tx.version = 0;
txb = tx_to_blob(tx);
printf("FROM submit jl777\n");
if ( !m_core->handle_incoming_tx(txb,tvc,false) )
{
LOG_PRINT_L0("[on_send_raw_tx]: Failed to process tx");
return(0);
}
if ( tvc.m_verifivation_failed )
{
LOG_PRINT_L0("[on_send_raw_tx]: tx verification failed");
return(0);
}
if( !tvc.m_should_be_relayed )
{
LOG_PRINT_L0("[on_send_raw_tx]: tx accepted, but not relayed");
return(0);
}
req.txs.push_back(txb);
m_core->get_protocol()->relay_transactions(req,fake_context);
get_transaction_hash(tx,h);
txid = calc_txid((unsigned char *)&h,sizeof(h));
return(txid);
}
//------------------------------------------------------------------------------------------------------------------------------
bool wallet_rpc_server::on_withdrawtelepod(const wallet_rpc::COMMAND_RPC_WITHDRAWTELEPOD::request& req, wallet_rpc::COMMAND_RPC_WITHDRAWTELEPOD::response& res, epee::json_rpc::error& er, connection_context& cntx)
{
currency::transaction tx2 = AUTO_VAL_INIT(tx2);
//parse destination add
currency::account_public_address acc_addr = AUTO_VAL_INIT(acc_addr);
if (!currency::get_account_address_from_str(acc_addr, req.addr))
{
LOG_ERROR("Failed to build_transaction_from_telepod(...)");
res.status = "BAD_ADDRESS";
return true;
}
if (!build_transaction_from_telepod(req.tpd, acc_addr, tx2, res.status))
{
LOG_ERROR("Failed to build_transaction_from_telepod(...)");
return true;
}
//send transaction to daemon
currency::COMMAND_RPC_SEND_RAW_TX::request req_send_raw;
req_send_raw.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx2));
currency::COMMAND_RPC_SEND_RAW_TX::response rsp_send_raw;
bool r = m_wallet.get_core_proxy()->call_COMMAND_RPC_SEND_RAW_TX(req_send_raw, rsp_send_raw);
if (!r || rsp_send_raw.status != CORE_RPC_STATUS_OK)
{
LOG_ERROR("Problem with construct_tx(....), blobl size os too big: " << get_object_blobsize(tx2));
res.status = "INTERNAL_ERROR";
return true;
}
res.status = "OK";
LOG_PRINT_GREEN("TELEPOD WITHDRAWN [" << currency::print_money(currency::get_outs_money_amount(tx2)) << "BBR, tx_id: ]" << currency::get_transaction_hash(tx2), LOG_LEVEL_0);
return true;
}
bool core::queryBlocks(const std::list<crypto::hash>& knownBlockIds, uint64_t timestamp,
uint64_t& resStartHeight, uint64_t& resCurrentHeight, uint64_t& resFullOffset, std::list<BlockFullInfo>& entries) {
LockedBlockchainStorage lbs(m_blockchain_storage);
uint64_t currentHeight = lbs->get_current_blockchain_height();
uint64_t startOffset = 0;
if (!lbs->find_blockchain_supplement(knownBlockIds, startOffset)) {
return false;
}
uint64_t startFullOffset = 0;
if (!lbs->getLowerBound(timestamp, startOffset, startFullOffset))
startFullOffset = startOffset;
resFullOffset = startFullOffset;
if (startOffset != startFullOffset) {
std::list<crypto::hash> blockIds;
if (!lbs->getBlockIds(startOffset, std::min(uint64_t(BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT), startFullOffset - startOffset), blockIds)) {
return false;
}
for (const auto& id : blockIds) {
entries.push_back(BlockFullInfo());
entries.back().block_id = id;
}
}
auto blocksLeft = std::min(BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT - entries.size(), size_t(BLOCKS_SYNCHRONIZING_DEFAULT_COUNT));
if (blocksLeft) {
std::list<Block> blocks;
lbs->get_blocks(startFullOffset, blocksLeft, blocks);
for (auto& b : blocks) {
BlockFullInfo item;
item.block_id = get_block_hash(b);
if (b.timestamp >= timestamp) {
// query transactions
std::list<Transaction> txs;
std::list<crypto::hash> missedTxs;
lbs->get_transactions(b.txHashes, txs, missedTxs);
// fill data
block_complete_entry& completeEntry = item;
completeEntry.block = block_to_blob(b);
for (auto& tx : txs) {
completeEntry.txs.push_back(tx_to_blob(tx));
}
}
entries.push_back(std::move(item));
}
}
resCurrentHeight = currentHeight;
resStartHeight = startOffset;
return true;
}
