For an immediately usable, binary version of the Bitcoin Core software, see

https://bitcoincore.org/en/download/.

License

-------

dnl Don't allow extended (non-ASCII) symbols in identifiers. This is easier for code review.

AX_CHECK_COMPILE_FLAG([-fno-extended-identifiers], [CORE_CXXFLAGS="$CORE_CXXFLAGS -fno-extended-identifiers"], [], [$CXXFLAG_WERROR])

enable_sse42=no

enable_sse41=no

enable_avx2=no

time-machine() {

# shellcheck disable=SC2086

guix time-machine --url=https://git.savannah.gnu.org/git/guix.git \

--cores="$JOBS" \

--keep-failed \

--fallback \

bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data& data, int version)

{

// Generate random temporary filename

std::string tmpfn = strprintf("%s.%04x", prefix, randv);

// open temp output file, and associate with CAutoFile

#include <chainparamsbase.h>

#include <clientversion.h>

#include <policy/feerate.h>

#include <rpc/client.h>

#include <rpc/mining.h>

#include <rpc/protocol.h>

#include <rpc/request.h>

#include <tinyformat.h>

#include <util/strencodings.h>

#include <util/system.h>

#include <util/translation.h>

#include <util/url.h>

#include <algorithm>

#include <cmath>

#include <functional>

#include <memory>

#include <optional>

#include <string>

#include <tuple>

#include <event2/keyvalq_struct.h>

#include <support/events.h>

const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;

UrlDecodeFn* const URL_DECODE = urlDecode;

if (conn_type == "addr-fetch") return "addr";

return "";

}

public:

static constexpr int ID_PEERINFO = 0;

#include <unordered_map>

CBlockHeaderAndShortTxIDs::CBlockHeaderAndShortTxIDs(const CBlock& block, bool fUseWTXID) :

shorttxids(block.vtx.size() - 1), prefilledtxn(1), header(block) {

FillShortTxIDSelector();

//TODO: Use our mempool prior to block acceptance to predictively fill more than just the coinbase

void CRollingBloomFilter::reset()

{

nEntriesThisGeneration = 0;

nGeneration = 1;

std::fill(data.begin(), data.end(), 0);

constexpr uint8_t DB_BEST_BLOCK{'B'};

template <typename... Args>

static void FatalError(const char* fmt, const Args&... args)

if (!m_synced) {

auto& consensus_params = Params().GetConsensus();

while (true) {

if (m_interrupt) {

SetBestBlockIndex(pindex);

pindex = pindex_next;

}

if (last_log_time + SYNC_LOG_INTERVAL < current_time) {

LogPrintf("Syncing %s with block chain from height %d\n",

GetName(), pindex->nHeight);

assert(!node.banman);

node.banman = std::make_unique<BanMan>(gArgs.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));

assert(!node.connman);

*node.addrman, *node.netgroupman, args.GetBoolArg("-networkactive", true));

assert(!node.fee_estimator);

LogPrint(BCLog::NET, "net: setting try another outbound peer=%s\n", flag ? "true" : "false");

}

// Return the number of peers we have over our outbound connection limit

// Exclude peers that are marked for disconnect, or are going to be

// disconnected soon (eg ADDR_FETCH and FEELER)

if (fFeeler) {

// Add small amount of random noise before connection to avoid synchronization.

if (!interruptNet.sleep_for(std::chrono::milliseconds(randsleep)))

return;

LogPrint(BCLog::NET, "Making feeler connection to %s\n", addrConnect.ToString());

#include <crypto/siphash.h>

#include <hash.h>

#include <i2p.h>

#include <net_permissions.h>

#include <netaddress.h>

#include <netbase.h>

void SetTryNewOutboundPeer(bool flag);

bool GetTryNewOutboundPeer() const;

// Return the number of outbound peers we have in excess of our target (eg,

// if we previously called SetTryNewOutboundPeer(true), and have since set

}

if (pingSend) {

peer.m_ping_queued = false;

peer.m_ping_start = now;

if (node_to.GetCommonVersion() > BIP0031_VERSION) {

{

public:

CServiceHash()

{

}

#include <interfaces/chain.h>

#include <interfaces/node.h>

#include <qt/clientmodel.h>

#include <qt/editaddressdialog.h>

#include <qt/optionsmodel.h>

#include <chrono>

#include <QApplication>

#include <QMessageBox>

using wallet::AddWallet;

using wallet::CWallet;

EditAddressDialog editAddressDialog(EditAddressDialog::NewSendingAddress);

editAddressDialog.setModel(walletModel.getAddressTableModel());

EditAddressAndSubmit(

&editAddressDialog, QString("uhoh"), preexisting_r_address,

QString(

"Address \"%1\" already exists as a receiving address with label "

"\"%2\" and so cannot be added as a sending address."

).arg(preexisting_r_address).arg(r_label));

check_addbook_size(2);

EditAddressAndSubmit(

&editAddressDialog, QString("uhoh, different"), preexisting_s_address,

"The entered address \"%1\" is already in the address book with "

"label \"%2\"."

).arg(preexisting_s_address).arg(s_label));

check_addbook_size(2);

// Submit a new address which should add successfully - we expect the

// warning message to be blank.

EditAddressAndSubmit(

&editAddressDialog, QString("new"), new_address, QString(""));

check_addbook_size(3);

}

} // namespace

Q_EMIT notifyWatchonlyChanged(fHaveWatchonly);

}

{

return IsValidDestinationString(address.toStdString());

}

return SendCoinsReturn(OK);

}

{

return optionsModel;

}

{

return addressTableModel;

}

{

return transactionTableModel;

}

{

return recentRequestsTableModel;

}

QString strPurpose = QString::fromStdString(purpose);

qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);

Q_ARG(QString, strAddress),

Q_ARG(QString, strLabel),

Q_ARG(bool, isMine),

return true;

}

{

CTxDestination dest = DecodeDestination(sAddress);

bool res = false;

return name.isEmpty() ? "["+tr("default wallet")+"]" : name;

}

{

return m_node.walletLoader().getWallets().size() > 1;

}

Unlocked // wallet->IsCrypted() && !wallet->IsLocked()

};

EncryptionStatus getEncryptionStatus() const;

// Check address for validity

// Return status record for SendCoins, contains error id + information

struct SendCoinsReturn

UnlockContext requestUnlock();

bool bumpFee(uint256 hash, uint256& new_hash);

static bool isWalletEnabled();

QString getWalletName() const;

QString getDisplayName() const;

void refresh(bool pk_hash_only = false);

bool g_mock_deterministic_tests{false};

{

return FastRandomContext(g_mock_deterministic_tests).randrange(nMax);

}

uint256 GetRandHash() noexcept

{

uint256 hash;

*/

void GetRandBytes(Span<unsigned char> bytes) noexcept;

/** Generate a uniform random integer in the range [0..range). Precondition: range > 0 */

/** Generate a uniform random duration in the range [0..max). Precondition: max.count() > 0 */

template <typename D>

D GetRandomDuration(typename std::common_type<D>::type max) noexcept

* */

std::chrono::microseconds GetExponentialRand(std::chrono::microseconds now, std::chrono::seconds average_interval);

uint256 GetRandHash() noexcept;

/**

/** Generate a random boolean. */

bool randbool() noexcept { return randbits(1); }

// Compatibility with the C++11 UniformRandomBitGenerator concept

typedef uint64_t result_type;

static constexpr uint64_t min() { return 0; }

FILE* file{fsbridge::fopen(temppath, "wb")};

CAutoFile afile{file, SER_DISK, CLIENT_VERSION};

NodeContext& node = EnsureAnyNodeContext(request.context);

UniValue result = CreateUTXOSnapshot(

node, node.chainman->ActiveChainstate(), afile, path, temppath);

#include <scheduler.h>

#include <util/syscall_sandbox.h>

#include <util/time.h>

#include <functional>

#include <utility>

// the time of the first item on the queue:

while (!shouldStop() && !taskQueue.empty()) {

if (newTaskScheduled.wait_until(lock, timeToWaitFor) == std::cv_status::timeout) {

break; // Exit loop after timeout, it means we reached the time of the event

}

newTaskScheduled.notify_one();

}

{

{

LOCK(newTaskMutex);

LOCK(newTaskMutex);

// use temp_queue to maintain updated schedule

for (const auto& element : taskQueue) {

temp_queue.emplace_hint(temp_queue.cend(), element.first - delta_seconds, element.second);

scheduleFromNow([this, f, delta] { Repeat(*this, f, delta); }, delta);

}

{

LOCK(newTaskMutex);

size_t result = taskQueue.size();

if (m_are_callbacks_running) return;

if (m_callbacks_pending.empty()) return;

}

}

void SingleThreadedSchedulerClient::ProcessQueue()

typedef std::function<void()> Function;

/** Call func at/after time t */

/** Call f once after the delta has passed */

void scheduleFromNow(Function f, std::chrono::milliseconds delta)

{

}

/**

* Returns number of tasks waiting to be serviced,

* and first and last task times

*/

/** Returns true if there are threads actively running in serviceQueue() */

bool AreThreadsServicingQueue() const;

private:

mutable Mutex newTaskMutex;

std::condition_variable newTaskScheduled;

int nThreadsServicingQueue GUARDED_BY(newTaskMutex){0};

bool stopRequested GUARDED_BY(newTaskMutex){false};

bool stopWhenEmpty GUARDED_BY(newTaskMutex){false};

return 0;

}

std::signal(SIGABRT, signal_handler);

int tested = 0;

for (int i = 1; i < argc; ++i) {

fs::path input_path(*(argv + i));

buffer.clear();

}

}

#endif

return 0;

}

FastRandomContext ctx2(true);

for (int i = 10; i > 0; --i) {

BOOST_CHECK_EQUAL(GetRandMicros(std::chrono::hours{1}).count(), 2917185654);

BOOST_CHECK_EQUAL(GetRandMillis(std::chrono::hours{1}).count(), 2144374);

}

BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());

BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());

BOOST_CHECK_EQUAL(ctx1.rand64(), ctx2.rand64());

// Check that a nondeterministic ones are not

g_mock_deterministic_tests = false;

for (int i = 10; i > 0; --i) {

BOOST_CHECK(GetRandMicros(std::chrono::hours{1}) != std::chrono::microseconds{2917185654});

BOOST_CHECK(GetRandMillis(std::chrono::hours{1}) != std::chrono::milliseconds{2144374});

}

BOOST_AUTO_TEST_SUITE(scheduler_tests)

{

{

std::lock_guard<std::mutex> lock(mutex);

counter += delta;

}

if (rescheduleTime != noTime) {

CScheduler::Function f = std::bind(&microTask, std::ref(s), std::ref(mutex), std::ref(counter), -delta + 1, noTime);

s.schedule(f, rescheduleTime);

auto randomMsec = [](FastRandomContext& rc) -> int { return -11 + (int)rc.randrange(1012); }; // [-11, 1000]

auto randomDelta = [](FastRandomContext& rc) -> int { return -1000 + (int)rc.randrange(2001); }; // [-1000, 1000]

size_t nTasks = microTasks.getQueueInfo(first, last);

BOOST_CHECK(nTasks == 0);

for (int i = 0; i < 100; ++i) {

int whichCounter = zeroToNine(rng);

CScheduler::Function f = std::bind(&microTask, std::ref(microTasks),

std::ref(counterMutex[whichCounter]), std::ref(counter[whichCounter]),

microThreads.emplace_back(std::bind(&CScheduler::serviceQueue, &microTasks));

UninterruptibleSleep(std::chrono::microseconds{600});

// More threads and more tasks:

for (int i = 0; i < 5; i++)

microThreads.emplace_back(std::bind(&CScheduler::serviceQueue, &microTasks));

for (int i = 0; i < 100; i++) {

int whichCounter = zeroToNine(rng);

CScheduler::Function f = std::bind(&microTask, std::ref(microTasks),

std::ref(counterMutex[whichCounter]), std::ref(counter[whichCounter]),

Mutex mtx;

WAIT_LOCK(mtx, lock);

};

BOOST_CHECK(std::cv_status::timeout == no_wait(std::chrono::seconds{1}));

scheduler.scheduleFromNow(dummy, std::chrono::minutes{8});

// check taskQueue

size_t num_tasks = scheduler.getQueueInfo(first, last);

BOOST_CHECK_EQUAL(num_tasks, 3ul);

BOOST_CHECK_EQUAL(counter, 2);

// check that the time of the remaining job has been updated

int delta = std::chrono::duration_cast<std::chrono::seconds>(first - now).count();

// should be between 2 & 3 minutes from now

BOOST_CHECK(delta > 2*60 && delta < 3*60);

BOOST_CHECK_EQUAL(ParseISO8601DateTime("1970-01-01T00:00:00Z"), 0);

BOOST_CHECK_EQUAL(ParseISO8601DateTime("1960-01-01T00:00:00Z"), 0);

BOOST_CHECK_EQUAL(ParseISO8601DateTime("2011-09-30T23:36:17Z"), 1317425777);

}

BOOST_AUTO_TEST_CASE(util_FormatISO8601Date)

{

SetMockTime(111);

// Check that mock time does not change after a sleep

BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter

BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());

BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());

}

SetMockTime(0);

const auto ms_0 = GetTime<std::chrono::milliseconds>();

const auto us_0 = GetTime<std::chrono::microseconds>();

BOOST_CHECK(ms_0 < GetTime<std::chrono::milliseconds>());

BOOST_CHECK(us_0 < GetTime<std::chrono::microseconds>());

}

#include <random.h>

#include <util/bytevectorhash.h>

{

}

size_t ByteVectorHash::operator()(const std::vector<unsigned char>& input) const

#include <limits>

size_t SaltedSipHasher::operator()(const Span<const unsigned char>& script) const

{

return int64_t{GetSystemTime<std::chrono::microseconds>().count()};

}

int64_t GetTime() { return GetTime<std::chrono::seconds>().count(); }

std::string FormatISO8601DateTime(int64_t nTime) {

using namespace std::chrono_literals;

void UninterruptibleSleep(const std::chrono::microseconds& n);

/**

*

* be avoided in code. Though, it is still preferred to an inline t.count() to

* protect against a reliance on the exact type of t.

*

* interface that doesn't support std::chrono (e.g. RPC, debug log, or the GUI)

*/

constexpr int64_t count_seconds(std::chrono::seconds t) { return t.count(); }

constexpr int64_t count_milliseconds(std::chrono::milliseconds t) { return t.count(); }

constexpr int64_t count_microseconds(std::chrono::microseconds t) { return t.count(); }

int64_t GetTimeMillis();

/** Returns the system time (not mockable) */

int64_t GetTimeMicros();

/**

* DEPRECATED

/** Return system time (or mocked time, if set) */

template <typename T>

T GetTime();

/**

* ISO 8601 formatting is preferred. Use the FormatISO8601{DateTime,Date}

full_flush_completed = true;

TRACE5(utxocache, flush,

(int64_t)(GetTimeMicros() - nNow.count()), // in microseconds (µs)

(bool)fFlushForPrune);

}

}

if (ret != 0)

LogPrintf("BerkeleyEnvironment::Close: Error %d closing database environment: %s\n", ret, DbEnv::strerror(ret));

if (!fMockDb)

if (error_file) fclose(error_file);

return m_dbt.get_data();

}

{

return m_dbt.get_size();

}

namespace wallet {

struct WalletDatabaseFileId {

bool operator==(const WalletDatabaseFileId& rhs) const;

};

// delegate to Dbt

const void* get_data() const;

// conversion operator to access the underlying Dbt

operator Dbt*();

*/

CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_block, int start_height, std::optional<int> max_height, const WalletRescanReserver& reserver, bool fUpdate)

{

assert(reserver.isReserved());

if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {

ShowProgress(strprintf("%s " + _("Rescanning…").translated, GetDisplayName()), std::max(1, std::min(99, (int)(m_scanning_progress * 100))));

}

WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n", block_height, progress_current);

}

WalletLogPrintf("Rescan interrupted by shutdown request at block %d. Progress=%f\n", block_height, progress_current);

result.status = ScanResult::USER_ABORT;

} else {

}

return result;

}

# the size of the memory pool should be greater than 3x ~100 bytes

assert_greater_than(json_obj['bytes'], 300)

# Check that there are our submitted transactions in the TX memory pool

json_obj = self.test_rest_request("/mempool/contents")

raw_mempool_verbose = self.nodes[0].getrawmempool(verbose=True)

break

tmp_header = BytesIO(tmp_header_raw)

tmp_header.read(TIME_SIZE) # skip the timestamp field

assert(msgtype in MESSAGEMAP)

length: int = int.from_bytes(tmp_header.read(LENGTH_SIZE), "little")

data = f_in.read(length)

assert_equal(len(data), length)

out['txoutset_hash'], '1f7e3befd45dc13ae198dfbb22869a9c5c4196f8e9ef9735831af1288033f890')

assert_equal(out['nchaintx'], 101)

assert_raises_rpc_error(

-8, '{} already exists'.format(FILENAME), node.dumptxoutset, FILENAME)

if __name__ == '__main__':

DumptxoutsetTest().main()

import unittest

# Formatting. Default colors to empty strings.

try:

# Make sure python thinks it can write unicode to its stdout

"\u2713".encode("utf_8").decode(sys.stdout.encoding)

kernel32.SetConsoleMode(stderr, stderr_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)

# primitive formatting on supported

# terminal via ANSI escape sequences:

BOLD = ('\033[0m', '\033[1m')

GREEN = ('\033[0m', '\033[0;32m')

RED = ('\033[0m', '\033[0;31m')

TEST_EXIT_PASSED = 0

TEST_EXIT_SKIPPED = 77

args, unknown_args = parser.parse_known_args()

if not args.ansi:

BOLD = ("", "")

GREEN = ("", "")

RED = ("", "")

# args to be passed on always start with two dashes; tests are the remaining unknown args

tests = [arg for arg in unknown_args if arg[:2] != "--"]

color = RED

glyph = CROSS

elif self.status == "Skipped":

glyph = CIRCLE

return color[1] + "%s | %s%s | %s s\n" % (self.name.ljust(self.padding), glyph, self.status.ljust(7), self.time) + color[0]