TEST(parse_and_validate_tx_extra, fails_on_big_extra_nonce) { Logging::LoggerGroup logger; CryptoNote::Currency currency = CryptoNote::CurrencyBuilder(logger).currency(); CryptoNote::Transaction tx = AUTO_VAL_INIT(tx); CryptoNote::account_base acc; acc.generate(); CryptoNote::blobdata b(TX_EXTRA_NONCE_MAX_COUNT + 1, 0); ASSERT_FALSE(currency.constructMinerTx(0, 0, 10000000000000, 1000, currency.minimumFee(), acc.get_keys().m_account_address, tx, b, 1)); }
TEST(parse_and_validate_tx_extra, is_valid_tx_extra_parsed) { Logging::LoggerGroup logger; CryptoNote::Currency currency = CryptoNote::CurrencyBuilder(logger).currency(); CryptoNote::Transaction tx = AUTO_VAL_INIT(tx); CryptoNote::account_base acc; acc.generate(); CryptoNote::blobdata b = "dsdsdfsdfsf"; ASSERT_TRUE(currency.constructMinerTx(0, 0, 10000000000000, 1000, currency.minimumFee(), acc.get_keys().m_account_address, tx, b, 1)); crypto::public_key tx_pub_key = CryptoNote::get_tx_pub_key_from_extra(tx); ASSERT_NE(tx_pub_key, CryptoNote::null_pkey); }
std::error_code TestWallet::init() { CryptoNote::account_base walletAccount; walletAccount.generate(); WalletAccountKeys walletKeys; walletKeys.spendPublicKey = reinterpret_cast<const WalletPublicKey&>(walletAccount.get_keys().m_account_address.m_spendPublicKey); walletKeys.spendSecretKey = reinterpret_cast<const WalletSecretKey&>(walletAccount.get_keys().m_spend_secret_key); walletKeys.viewPublicKey = reinterpret_cast<const WalletPublicKey&>(walletAccount.get_keys().m_account_address.m_viewPublicKey); walletKeys.viewSecretKey = reinterpret_cast<const WalletSecretKey&>(walletAccount.get_keys().m_view_secret_key); m_wallet->initWithKeys(walletKeys, TEST_PASSWORD); m_synchronizationCompleted.wait(); return m_lastSynchronizationResult; }
bool init_output_indices(map_output_idx_t& outs, std::map<uint64_t, std::vector<size_t> >& outs_mine, const std::vector<cryptonote::Block>& blockchain, const map_hash2tx_t& mtx, const cryptonote::account_base& from) { BOOST_FOREACH (const Block& blk, blockchain) { vector<const Transaction*> vtx; vtx.push_back(&blk.minerTx); for (const crypto::hash& h : blk.txHashes) { const map_hash2tx_t::const_iterator cit = mtx.find(h); if (mtx.end() == cit) throw std::runtime_error("block contains an unknown tx hash"); vtx.push_back(cit->second); } //vtx.insert(vtx.end(), blk.); // TODO: add all other txes for (size_t i = 0; i < vtx.size(); i++) { const Transaction &tx = *vtx[i]; size_t keyIndex = 0; for (size_t j = 0; j < tx.vout.size(); ++j) { const TransactionOutput &out = tx.vout[j]; if (out.target.type() == typeid(TransactionOutputToKey)) { output_index oi(out.target, out.amount, boost::get<TransactionInputGenerate>(*blk.minerTx.vin.begin()).height, i, j, &blk, vtx[i]); outs[out.amount].push_back(oi); size_t tx_global_idx = outs[out.amount].size() - 1; outs[out.amount][tx_global_idx].idx = tx_global_idx; // Is out to me? if (is_out_to_acc(from.get_keys(), boost::get<TransactionOutputToKey>(out.target), get_tx_pub_key_from_extra(tx), keyIndex)) { outs_mine[out.amount].push_back(tx_global_idx); } ++keyIndex; } else if (out.target.type() == typeid(TransactionOutputMultisignature)) { keyIndex += boost::get<TransactionOutputMultisignature>(out.target).keys.size(); } } } }
bool test_generator::constructMaxSizeBlock(CryptoNote::Block& blk, const CryptoNote::Block& blkPrev, const CryptoNote::account_base& minerAccount, size_t medianBlockCount/* = 0*/, const std::list<CryptoNote::Transaction>& txList/* = std::list<CryptoNote::Transaction>()*/) { std::vector<size_t> blockSizes; medianBlockCount = medianBlockCount == 0 ? m_currency.rewardBlocksWindow() : medianBlockCount; getLastNBlockSizes(blockSizes, get_block_hash(blkPrev), medianBlockCount); size_t median = Common::medianValue(blockSizes); size_t blockGrantedFullRewardZone = defaultMajorVersion <= BLOCK_MAJOR_VERSION_1 ? CryptoNote::parameters::CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1 : m_currency.blockGrantedFullRewardZone(); median = std::max(median, blockGrantedFullRewardZone); uint64_t totalFee = 0; size_t txsSize = 0; std::vector<crypto::hash> txHashes; for (auto& tx : txList) { uint64_t fee = 0; bool r = get_tx_fee(tx, fee); CHECK_AND_ASSERT_MES(r, false, "wrong transaction passed to construct_max_size_block"); totalFee += fee; txsSize += get_object_blobsize(tx); txHashes.push_back(get_transaction_hash(tx)); } Transaction minerTx; bool r = constructMinerTxBySize(m_currency, minerTx, get_block_height(blkPrev) + 1, getAlreadyGeneratedCoins(blkPrev), minerAccount.get_keys().m_account_address, blockSizes, 2 * median - txsSize, 2 * median, totalFee, defaultMajorVersion > BLOCK_MAJOR_VERSION_1); if (!r) { return false; } return constructBlockManually(blk, blkPrev, minerAccount, test_generator::bf_miner_tx | test_generator::bf_tx_hashes, 0, 0, 0, crypto::hash(), 0, minerTx, txHashes, txsSize, totalFee); }
bool test_generator::constructBlock(CryptoNote::Block& blk, uint32_t height, const crypto::hash& prevId, const CryptoNote::account_base& minerAcc, uint64_t timestamp, uint64_t alreadyGeneratedCoins, std::vector<size_t>& blockSizes, const std::list<CryptoNote::Transaction>& txList) { blk.majorVersion = defaultMajorVersion; blk.minorVersion = defaultMinorVersion; blk.timestamp = timestamp; blk.prevId = prevId; blk.txHashes.reserve(txList.size()); for (const Transaction &tx : txList) { crypto::hash tx_hash; get_transaction_hash(tx, tx_hash); blk.txHashes.push_back(tx_hash); } uint64_t totalFee = 0; size_t txsSize = 0; for (auto& tx : txList) { uint64_t fee = 0; bool r = get_tx_fee(tx, fee); CHECK_AND_ASSERT_MES(r, false, "wrong transaction passed to construct_block"); totalFee += fee; txsSize += get_object_blobsize(tx); } blk.minerTx = boost::value_initialized<Transaction>(); size_t targetBlockSize = txsSize + get_object_blobsize(blk.minerTx); while (true) { if (!m_currency.constructMinerTx(height, Common::medianValue(blockSizes), alreadyGeneratedCoins, targetBlockSize, totalFee, minerAcc.get_keys().m_account_address, blk.minerTx, blobdata(), 10)) { return false; } size_t actualBlockSize = txsSize + get_object_blobsize(blk.minerTx); if (targetBlockSize < actualBlockSize) { targetBlockSize = actualBlockSize; } else if (actualBlockSize < targetBlockSize) { size_t delta = targetBlockSize - actualBlockSize; blk.minerTx.extra.resize(blk.minerTx.extra.size() + delta, 0); actualBlockSize = txsSize + get_object_blobsize(blk.minerTx); if (actualBlockSize == targetBlockSize) { break; } else { CHECK_AND_ASSERT_MES(targetBlockSize < actualBlockSize, false, "Unexpected block size"); delta = actualBlockSize - targetBlockSize; blk.minerTx.extra.resize(blk.minerTx.extra.size() - delta); actualBlockSize = txsSize + get_object_blobsize(blk.minerTx); if (actualBlockSize == targetBlockSize) { break; } else { CHECK_AND_ASSERT_MES(actualBlockSize < targetBlockSize, false, "Unexpected block size"); blk.minerTx.extra.resize(blk.minerTx.extra.size() + delta, 0); targetBlockSize = txsSize + get_object_blobsize(blk.minerTx); } } } else { break; } } if (blk.majorVersion >= BLOCK_MAJOR_VERSION_2) { blk.parentBlock.majorVersion = BLOCK_MAJOR_VERSION_1; blk.parentBlock.minorVersion = BLOCK_MINOR_VERSION_0; blk.parentBlock.numberOfTransactions = 1; CryptoNote::tx_extra_merge_mining_tag mmTag; mmTag.depth = 0; if (!CryptoNote::get_aux_block_header_hash(blk, mmTag.merkle_root)) { return false; } blk.parentBlock.minerTx.extra.clear(); if (!CryptoNote::append_mm_tag_to_extra(blk.parentBlock.minerTx.extra, mmTag)) { return false; } } // Nonce search... blk.nonce = 0; crypto::cn_context context; while (!miner::find_nonce_for_given_block(context, blk, getTestDifficulty())) { blk.timestamp++; } addBlock(blk, txsSize, totalFee, blockSizes, alreadyGeneratedCoins); return true; }