BlockMiningParameters MinerManager::requestMiningParameters(System::Dispatcher& dispatcher, const std::string& daemonHost, uint16_t daemonPort, const std::string& miningAddress) {
try {
HttpClient client(dispatcher, daemonHost, daemonPort);
COMMAND_RPC_GETBLOCKTEMPLATE::request request;
request.wallet_address = miningAddress;
request.reserve_size = 0;
COMMAND_RPC_GETBLOCKTEMPLATE::response response;
System::EventLock lk(m_httpEvent);
JsonRpc::invokeJsonRpcCommand(client, "getblocktemplate", request, response);
if (response.status != CORE_RPC_STATUS_OK) {
throw std::runtime_error("Core responded with wrong status: " + response.status);
}
BlockMiningParameters params;
params.difficulty = response.difficulty;
if(!fromBinaryArray(params.blockTemplate, Common::fromHex(response.blocktemplate_blob))) {
throw std::runtime_error("Couldn't deserialize block template");
}
m_logger(Logging::DEBUGGING) << "Requested block template with previous block hash: " << Common::podToHex(params.blockTemplate.previousBlockHash);
return params;
} catch (std::exception& e) {
m_logger(Logging::WARNING) << "Couldn't get block template: " << e.what();
throw;
}
}
bool Currency::generateGenesisBlock() {
m_genesisBlock = boost::value_initialized<Block>();
// Hard code coinbase tx in genesis block, because "tru" generating tx use random, but genesis should be always the same
std::string genesisCoinbaseTxHex = GENESIS_COINBASE_TX_HEX;
BinaryArray minerTxBlob;
bool r =
fromHex(genesisCoinbaseTxHex, minerTxBlob) &&
fromBinaryArray(m_genesisBlock.baseTransaction, minerTxBlob);
if (!r) {
logger(ERROR, BRIGHT_RED) << "failed to parse coinbase tx from hard coded blob";
return false;
}
m_genesisBlock.majorVersion = BLOCK_MAJOR_VERSION_1;
m_genesisBlock.minorVersion = BLOCK_MINOR_VERSION_0;
m_genesisBlock.timestamp = GENESIS_TIMESTAMP;
m_genesisBlock.nonce = GENESIS_NONCE;
if (m_testnet) {
++m_genesisBlock.nonce;
}
//miner::find_nonce_for_given_block(bl, 1, 0);
return true;
}
std::error_code InProcessNode::doQueryBlocksLite(std::vector<Crypto::Hash>&& knownBlockIds, uint64_t timestamp, std::vector<BlockShortEntry>& newBlocks, uint32_t& startHeight) {
uint32_t currentHeight, fullOffset;
std::vector<CryptoNote::BlockShortInfo> entries;
if (!core.queryBlocksLite(knownBlockIds, timestamp, startHeight, currentHeight, fullOffset, entries)) {
return make_error_code(CryptoNote::error::INTERNAL_NODE_ERROR);
}
for (const auto& entry: entries) {
BlockShortEntry bse;
bse.blockHash = entry.blockId;
bse.hasBlock = false;
if (!entry.block.empty()) {
bse.hasBlock = true;
if (!fromBinaryArray(bse.block, asBinaryArray(entry.block))) {
return std::make_error_code(std::errc::invalid_argument);
}
}
for (const auto& tsi: entry.txPrefixes) {
TransactionShortInfo tpi;
tpi.txId = tsi.txHash;
tpi.txPrefix = tsi.txPrefix;
bse.txsShortInfo.push_back(std::move(tpi));
}
newBlocks.push_back(std::move(bse));
}
return std::error_code();
}
bool parseAndValidateTransactionFromBinaryArray(const BinaryArray& tx_blob, Transaction& tx, Hash& tx_hash, Hash& tx_prefix_hash) {
if (!fromBinaryArray(tx, tx_blob)) {
return false;
}
//TODO: validate tx
cn_fast_hash(tx_blob.data(), tx_blob.size(), tx_hash);
getObjectHash(*static_cast<TransactionPrefix*>(&tx), tx_prefix_hash);
return true;
}
//-----------------------------------------------------------------------
bool parseAccountAddressString(uint64_t& prefix, AccountPublicAddress& adr, const std::string& str) {
std::string data;
return
Tools::Base58::decode_addr(str, prefix, data) &&
fromBinaryArray(adr, asBinaryArray(data)) &&
// ::serialization::parse_binary(data, adr) &&
check_key(adr.spendPublicKey) &&
check_key(adr.viewPublicKey);
}
bool restoreCachedTransactions(const std::vector<BinaryArray>& binaryTransactions,
std::vector<CachedTransaction>& transactions) {
transactions.reserve(binaryTransactions.size());
for (auto binaryTransaction : binaryTransactions) {
Transaction transaction;
if (!fromBinaryArray(transaction, binaryTransaction)) {
return false;
}
transactions.emplace_back(std::move(transaction));
}
return true;
}
