Inside Bitcoin

251        raise RuntimeError("JSON encode/decode loses precision")
252
253
254class Binaries:
255    """Helper class to provide information about bitcoin binaries
256
257    Attributes:
258        paths: Object returned from get_binary_paths() containing information
259            which binaries and command lines to use from environment variables and
260            the config file.
261        bin_dir: An optional string containing a directory path to look for
262            binaries, which takes precedence over the paths above, if specified.
263            This is used by tests calling binaries from previous releases.
264    """
265    def __init__(self, paths, bin_dir, *, use_valgrind=False):
266        self.paths = paths
267        self.bin_dir = bin_dir
268        suppressions_file = pathlib.Path(__file__).resolve().parents[3] / "test" / "sanitizer_suppressions" / "valgrind.supp"
269        self.valgrind_cmd = [
270            "valgrind",
271            f"--suppressions={suppressions_file}",
272            "--gen-suppressions=all",
273            "--trace-children=yes",  # Needed for 'bitcoin' wrapper
274            "--exit-on-first-error=yes",
275            "--error-exitcode=1",
276            "--quiet",
277        ] if use_valgrind else []
278
279    def node_argv(self, **kwargs):
280        "Return argv array that should be used to invoke bitcoind"
281        return self._argv("node", self.paths.bitcoind, **kwargs)
282
283    def rpc_argv(self):
284        "Return argv array that should be used to invoke bitcoin-cli"
285        # Add -nonamed because "bitcoin rpc" enables -named by default, but bitcoin-cli doesn't
286        return self._argv("rpc", self.paths.bitcoincli) + ["-nonamed"]
287
288    def bench_argv(self):
289        "Return argv array that should be used to invoke bench_bitcoin"
290        return self._argv("bench", self.paths.bitcoin_bench)
291
292    def tx_argv(self):
293        "Return argv array that should be used to invoke bitcoin-tx"
294        return self._argv("tx", self.paths.bitcointx)
295
296    def util_argv(self):
297        "Return argv array that should be used to invoke bitcoin-util"
298        return self._argv("util", self.paths.bitcoinutil)
299
300    def wallet_argv(self):
301        "Return argv array that should be used to invoke bitcoin-wallet"
302        return self._argv("wallet", self.paths.bitcoinwallet)
303
304    def chainstate_argv(self):
305        "Return argv array that should be used to invoke bitcoin-chainstate"
306        return self._argv("chainstate", self.paths.bitcoinchainstate)
307
308    def _argv(self, command, bin_path, *, need_ipc=False, use_gui=False):
309        """Return argv array that should be used to invoke the command.
310
311        It either uses the bitcoin wrapper executable (if BITCOIN_CMD, need_ipc,
312        or use_gui are set), or the direct binary path (bitcoind, etc). When
313        bin_dir is set (by tests calling binaries from previous releases) it
314        always uses the direct path.
315
316        The returned args include valgrind, except when bin_dir is set
317        (previous releases). Also, valgrind will only apply to the bitcoin
318        wrapper executable directly, not to the commands that `bitcoin` calls.
319        """
320        if self.bin_dir is not None:
321            return [os.path.join(self.bin_dir, os.path.basename(bin_path))]
322        elif self.paths.bitcoin_cmd is not None or need_ipc or use_gui:
323            # If the current test needs IPC or GUI functionality, use the
324            # bitcoin wrapper binary and add appropriate options.
325            bitcoin_cmd = self.paths.bitcoin_cmd or [self.paths.bitcoin_bin]
326            subcommand = "gui" if use_gui and command == "node" else command
327            return self.valgrind_cmd + bitcoin_cmd + (["-m"] if need_ipc else []) + [subcommand]
328        else:
329            return self.valgrind_cmd + [bin_path]
330
331
332def get_binary_paths(config):
333    """Get paths of all binaries from environment variables or their default values"""
334
335    paths = types.SimpleNamespace()
336    binaries = {
337        "bitcoin": "BITCOIN_BIN",
338        "bitcoind": "BITCOIND",
339        "bench_bitcoin": "BITCOIN_BENCH",
340        "bitcoin-cli": "BITCOINCLI",
341        "bitcoin-util": "BITCOINUTIL",
342        "bitcoin-tx": "BITCOINTX",
343        "bitcoin-chainstate": "BITCOINCHAINSTATE",
344        "bitcoin-wallet": "BITCOINWALLET",
345    }
346    # Set paths to bitcoin core binaries allowing overrides with environment
347    # variables.
348    for binary, env_variable_name in binaries.items():
349        default_filename = os.path.join(
350            config["environment"]["BUILDDIR"],
351            "bin",
352            binary + config["environment"]["EXEEXT"],
353        )
354        setattr(paths, env_variable_name.lower(), os.getenv(env_variable_name, default=default_filename))
355    # BITCOIN_CMD environment variable can be specified to invoke bitcoin
356    # wrapper binary instead of other executables.
357    paths.bitcoin_cmd = shlex.split(os.getenv("BITCOIN_CMD", "")) or None
358    return paths
359
360
361def export_env_build_path(config):
362    os.environ["PATH"] = os.pathsep.join([
363        os.path.join(config["environment"]["BUILDDIR"], "bin"),
364        os.environ["PATH"],
365    ])
366
367
368def count_bytes(hex_string):
369    return len(bytearray.fromhex(hex_string))
370
371
372def str_to_b64str(string):
373    return b64encode(string.encode('utf-8')).decode('ascii')
374
375
376def ceildiv(a, b):
377    """
378    Divide 2 ints and round up to next int rather than round down
379    Implementation requires python integers, which have a // operator that does floor division.
380    Other types like decimal.Decimal whose // operator truncates towards 0 will not work.
381    """
382    assert isinstance(a, int)
383    assert isinstance(b, int)
384    return -(-a // b)
385
386
387def random_bitflip(data):
388    data = list(data)
389    data[random.randrange(len(data))] ^= (1 << (random.randrange(8)))
390    return bytes(data)
391
392
393def get_fee(tx_size, feerate_btc_kvb):
394    """Calculate the fee in BTC given a feerate is BTC/kvB. Reflects CFeeRate::GetFee"""
395    feerate_sat_kvb = int(feerate_btc_kvb * Decimal(1e8)) # Fee in sat/kvb as an int to avoid float precision errors
396    target_fee_sat = ceildiv(feerate_sat_kvb * tx_size, 1000) # Round calculated fee up to nearest sat
397    return target_fee_sat / Decimal(1e8) # Return result in  BTC
398
399
400def satoshi_round(amount: Union[int, float, str], *, rounding: str) -> Decimal:
401    """Rounds a Decimal amount to the nearest satoshi using the specified rounding mode."""
402    return Decimal(amount).quantize(SATOSHI_PRECISION, rounding=rounding)
403
404
405def ensure_for(*, duration, f, check_interval=0.2):
406    """Check if the predicate keeps returning True for duration.
407
408    check_interval can be used to configure the wait time between checks.
409    Setting check_interval to 0 will allow to have two checks: one in the
410    beginning and one after duration.
411    """
412    # If check_interval is 0 or negative or larger than duration, we fall back
413    # to checking once in the beginning and once at the end of duration
414    if check_interval <= 0 or check_interval > duration:
415        check_interval = duration
416    time_end = time.time() + duration
417    predicate_source = "''''\n" + inspect.getsource(f) + "'''"
418    while True:
419        if not f():
420            raise AssertionError(f"Predicate {predicate_source} became false within {duration} seconds")
421        if time.time() > time_end:
422            return
423        time.sleep(check_interval)
424
425
426def wait_until_helper_internal(predicate, *, timeout=60, lock=None, timeout_factor=1.0, check_interval=0.05):
427    """Sleep until the predicate resolves to be True.
428
429    Warning: Note that this method is not recommended to be used in tests as it is
430    not aware of the context of the test framework. Using the `wait_until()` members
431    from `BitcoinTestFramework` or `P2PInterface` class ensures the timeout is
432    properly scaled. Furthermore, `wait_until()` from `P2PInterface` class in
433    `p2p.py` has a preset lock.
434    """
435    timeout = timeout * timeout_factor
436    time_end = time.time() + timeout
437
438    while time.time() < time_end:
439        if lock:
440            with lock:
441                if predicate():
442                    return
443        else:
444            if predicate():
445                return
446        time.sleep(check_interval)
447
448    # Print the cause of the timeout
449    predicate_source = "''''\n" + inspect.getsource(predicate) + "'''"
450    logger.error("wait_until() failed. Predicate: {}".format(predicate_source))
451    raise AssertionError("Predicate {} not true after {} seconds".format(predicate_source, timeout))
452
453
454def bpf_cflags():
455    return [
456        "-Wno-error=implicit-function-declaration",
457        "-Wno-duplicate-decl-specifier",  # https://github.com/bitcoin/bitcoin/issues/32322
458    ]
459
460
461def sha256sum_file(filename):
462    h = hashlib.sha256()
463    with open(filename, 'rb') as f:
464        d = f.read(4096)
465        while len(d) > 0:
466            h.update(d)
467            d = f.read(4096)
468    return h.digest()
469
470
471def util_xor(data, key, *, offset):
472    data = bytearray(data)
473    for i in range(len(data)):
474        data[i] ^= key[(i + offset) % len(key)]
475    return bytes(data)
476
477
478# RPC/P2P connection constants and functions
479############################################
480
481# The maximum number of nodes a single test can spawn
482MAX_NODES = 12
483# Don't assign p2p, rpc or tor ports lower than this
484PORT_MIN = int(os.getenv('TEST_RUNNER_PORT_MIN', default=11000))
485# The number of ports to "reserve" for p2p, rpc and tor, each
486PORT_RANGE = 5000
487
488
489class PortSeed:
490    # Must be initialized with a unique integer for each process
491    n = None
492
493def p2p_port(n):
494    assert n <= MAX_NODES
495    return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
496
497
498def rpc_port(n):
499    return p2p_port(n) + PORT_RANGE
500