Inside Bitcoin

501
502def tor_port(n):
503    return p2p_port(n) + PORT_RANGE * 2
504
505
506# Node functions
507################
508
509
510def initialize_datadir(dirname, n, chain, disable_autoconnect=True):
511    datadir = get_datadir_path(dirname, n)
512    if not os.path.isdir(datadir):
513        os.makedirs(datadir)
514    write_config(os.path.join(datadir, "bitcoin.conf"), n=n, chain=chain, disable_autoconnect=disable_autoconnect)
515    os.makedirs(os.path.join(datadir, 'stderr'), exist_ok=True)
516    os.makedirs(os.path.join(datadir, 'stdout'), exist_ok=True)
517    return datadir
518
519
520def write_config(config_path, *, n, chain, extra_config="", disable_autoconnect=True):
521    # Translate chain subdirectory name to config name
522    if chain == 'testnet3':
523        chain_name_conf_arg = 'testnet'
524        chain_name_conf_section = 'test'
525    else:
526        chain_name_conf_arg = chain
527        chain_name_conf_section = chain
528    with open(config_path, 'w') as f:
529        if chain_name_conf_arg:
530            f.write("{}=1\n".format(chain_name_conf_arg))
531        if chain_name_conf_section:
532            f.write("[{}]\n".format(chain_name_conf_section))
533        f.write("port=" + str(p2p_port(n)) + "\n")
534        f.write("rpcport=" + str(rpc_port(n)) + "\n")
535        # Disable server-side timeouts to avoid intermittent issues
536        f.write("rpcservertimeout=99000\n")
537        f.write("rpcdoccheck=1\n")
538        f.write("rpcthreads=2\n")
539        f.write("fallbackfee=0.0002\n")
540        f.write("server=1\n")
541        f.write("keypool=1\n")
542        f.write("discover=0\n")
543        f.write("dnsseed=0\n")
544        f.write("fixedseeds=0\n")
545        f.write("listenonion=0\n")
546        # Increase peertimeout to avoid disconnects while using mocktime.
547        # peertimeout is measured in mock time, so setting it large enough to
548        # cover any duration in mock time is sufficient. It can be overridden
549        # in tests.
550        f.write("peertimeout=999999999\n")
551        f.write("printtoconsole=0\n")
552        f.write("natpmp=0\n") # Avoid non-loopback network traffic during tests.
553        f.write("shrinkdebugfile=0\n")
554        # To improve SQLite wallet performance so that the tests don't timeout, use -unsafesqlitesync
555        f.write("unsafesqlitesync=1\n")
556        if disable_autoconnect:
557            f.write("connect=0\n")
558        # Limit max connections to mitigate test failures on some systems caused by the warning:
559        # "Warning: Reducing -maxconnections from <...> to <...> due to system limitations".
560        # For details, consult the `AppInitParameterInteraction` function in src/init.cpp.
561        #  available_fds = 256                // Same as FD_SETSIZE on NetBSD.
562        #  MIN_CORE_FDS = 151                 // Number of file descriptors required for core functionality.
563        #  MAX_ADDNODE_CONNECTIONS = 8        // Maximum number of -addnode outgoing nodes.
564        #  num_p2p_bind = 3                   // Maximum number of bound P2P interfaces (-bind and -whitebind) used in a test.
565        #  num_rpc_bind = 2                   // Maximum number of HTTP sockets used in a test.
566        #  DEFAULT_MAX_HTTP_CONNECTIONS = 16  // Reserved for connected HTTP clients.
567        #
568        #  min_required_fds = MIN_CORE_FDS + MAX_ADDNODE_CONNECTIONS + num_p2p_bind + num_rpc_bind + DEFAULT_MAX_HTTP_CONNECTIONS =
569        #    = 151 + 8 + 3 + 2 + 16 = 180;
570        #  num_p2p_max_connections = available_fds - min_required_fds = 256 - 180 = 76;
571        f.write("maxconnections=76\n")
572        f.write("par=" + str(min(2, os.cpu_count())) + "\n")
573        # Use a single prevoutfetch worker thread to keep per-node resource usage low.
574        f.write("prevoutfetchthreads=1\n")
575        f.write(extra_config)
576
577
578def get_datadir_path(dirname, n):
579    return pathlib.Path(dirname) / f"node{n}"
580
581
582def get_temp_default_datadir(temp_dir: pathlib.Path) -> tuple[dict, pathlib.Path]:
583    """Return os-specific environment variables that can be set to make the
584    GetDefaultDataDir() function return a datadir path under the provided
585    temp_dir, as well as the complete path it would return."""
586    if platform.system() == "Windows":
587        env = dict(APPDATA=str(temp_dir))
588        datadir = temp_dir / "Bitcoin"
589    else:
590        env = dict(HOME=str(temp_dir))
591        if platform.system() == "Darwin":
592            datadir = temp_dir / "Library/Application Support/Bitcoin"
593        else:
594            datadir = temp_dir / ".bitcoin"
595    return env, datadir
596
597
598def append_config(datadir, options):
599    with open(os.path.join(datadir, "bitcoin.conf"), 'a') as f:
600        for option in options:
601            f.write(option + "\n")
602
603
604def get_auth_cookie(datadir, chain):
605    user = None
606    password = None
607    if os.path.isfile(os.path.join(datadir, "bitcoin.conf")):
608        with open(os.path.join(datadir, "bitcoin.conf"), 'r') as f:
609            for line in f:
610                if line.startswith("rpcuser="):
611                    assert user is None  # Ensure that there is only one rpcuser line
612                    user = line.split("=")[1].strip("\n")
613                if line.startswith("rpcpassword="):
614                    assert password is None  # Ensure that there is only one rpcpassword line
615                    password = line.split("=")[1].strip("\n")
616    try:
617        with open(os.path.join(datadir, chain, ".cookie"), 'r') as f:
618            userpass = f.read()
619            split_userpass = userpass.split(':')
620            user = split_userpass[0]
621            password = split_userpass[1]
622    except OSError:
623        pass
624    if user is None or password is None:
625        raise ValueError("No RPC credentials")
626    return user, password
627
628
629# If a cookie file exists in the given datadir, delete it.
630def delete_cookie_file(datadir, chain):
631    if os.path.isfile(os.path.join(datadir, chain, ".cookie")):
632        logger.debug("Deleting leftover cookie file")
633        os.remove(os.path.join(datadir, chain, ".cookie"))
634
635
636def softfork_active(node, key):
637    """Return whether a softfork is active."""
638    return node.getdeploymentinfo()['deployments'][key]['active']
639
640
641def set_node_times(nodes, t):
642    for node in nodes:
643        node.setmocktime(t)
644
645
646def check_node_connections(*, node, num_in, num_out):
647    info = node.getnetworkinfo()
648    assert_equal(info["connections_in"], num_in)
649    assert_equal(info["connections_out"], num_out)
650
651
652# Transaction/Block functions
653#############################
654
655
656# Create large OP_RETURN txouts that can be appended to a transaction
657# to make it large (helper for constructing large transactions). The
658# total serialized size of the txouts is about 66k vbytes.
659def gen_return_txouts():
660    from .messages import CTxOut
661    from .script import CScript, OP_RETURN
662    txouts = [CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN, b'\x01'*67437]))]
663    assert_equal(sum([len(txout.serialize()) for txout in txouts]), 67456)
664    return txouts
665
666
667# Create a spend of each passed-in utxo, splicing in "txouts" to each raw
668# transaction to make it large.  See gen_return_txouts() above.
669def create_lots_of_big_transactions(mini_wallet, node, fee, tx_batch_size, txouts, utxos=None):
670    txids = []
671    use_internal_utxos = utxos is None
672    for _ in range(tx_batch_size):
673        tx = mini_wallet.create_self_transfer(
674            utxo_to_spend=None if use_internal_utxos else utxos.pop(),
675            fee=fee,
676        )["tx"]
677        tx.vout.extend(txouts)
678        res = node.testmempoolaccept([tx.serialize().hex()])[0]
679        assert_equal(res['fees']['base'], fee)
680        txids.append(node.sendrawtransaction(tx.serialize().hex()))
681    return txids
682
683
684def mine_large_block(test_framework, mini_wallet, node):
685    # generate a 66k transaction,
686    # and 14 of them is close to the 1MB block limit
687    txouts = gen_return_txouts()
688    fee = 100 * node.getnetworkinfo()["relayfee"]
689    create_lots_of_big_transactions(mini_wallet, node, fee, 14, txouts)
690    test_framework.generate(node, 1)
691
692
693def find_vout_for_address(node, txid, addr):
694    """
695    Locate the vout index of the given transaction sending to the
696    given address. Raises runtime error exception if not found.
697    """
698    tx = node.getrawtransaction(txid, True)
699    for i in range(len(tx["vout"])):
700        if addr == tx["vout"][i]["scriptPubKey"]["address"]:
701            return i
702    raise RuntimeError("Vout not found for address: txid=%s, addr=%s" % (txid, addr))
703
704
705def dumb_sync_blocks(*, src, dst, height=None):
706    """Sync blocks between `src` and `dst` nodes via RPC submitblock up to height."""
707    height = height or src.getblockcount()
708    for i in range(dst.getblockcount() + 1, height + 1):
709        block_hash = src.getblockhash(i)
710        # Use boolean verbosity for v0.14.x compatibility.
711        block = src.getblock(blockhash=block_hash, verbose=False)
712        dst.submitblock(block)
713    assert_equal(dst.getblockcount(), height)
714
715
716def sync_txindex(test_framework, node):
717    test_framework.log.debug("Waiting for node txindex to sync")
718    sync_start = int(time.time())
719    test_framework.wait_until(lambda: node.getindexinfo("txindex")["txindex"]["synced"])
720    test_framework.log.debug(f"Synced in {time.time() - sync_start} seconds")
721
722def wallet_importprivkey(wallet_rpc, privkey, timestamp, *, label=""):
723    desc = descsum_create("combo(" + privkey + ")")
724    req = [{
725        "desc": desc,
726        "timestamp": timestamp,
727        "label": label,
728    }]
729    import_res = wallet_rpc.importdescriptors(req)
730    assert_equal(import_res[0]["success"], True)
731
732def is_dir_writable(dir_path: pathlib.Path) -> bool:
733    """Return True if we can create a file in the directory, False otherwise"""
734    try:
735        tmp = dir_path / f".tmp_{random.randrange(1 << 32)}"
736        tmp.touch()
737        tmp.unlink()
738        return True
739    except OSError:
740        return False
741
742def bitflipper(input):
743    assert isinstance(input, bytes)
744    return (int.from_bytes(input, "little") ^ (1 << random.randrange(len(input) * 8))).to_bytes(len(input), "little")
745