[WIP] python bitcoind initialization

Author: benalleng

python/test/payjoin_integration_test.py

@@ -3,6 +3,7 @@
 import os
 import sys
 import httpx
+import logging
 
 from payjoin import *
 from typing import Optional
@@ -15,6 +16,8 @@
 )
 
 import hashlib
+import subprocess
+import shutil
 import unittest
 from pprint import *
 from bitcoin import SelectParams
@@ -34,7 +37,86 @@ def get_rpc_credentials_from_cookie(cookie_path):
         credentials = cookie_file.read().strip()
     return credentials.split(":")
 
-# Function to create and load a wallet if it doesn't already exist
+from typing import Optional, Tuple
+import time
+
+from pathlib import Path
+
+BITCOIND_DATADIR = Path("/tmp/bitcoind-test")
+COOKIE_PATH = BITCOIND_DATADIR / "regtest" / ".cookie"
+RPC_URL = "http://127.0.0.1:18443"
+
+def init_bitcoind():
+    bitcoind_exe = os.getenv("BITCOIND_EXE") or shutil.which("bitcoind")
+    if not bitcoind_exe:
+        raise RuntimeError("bitcoind not found")
+
+    args = [
+        bitcoind_exe,
+        "-regtest",
+        f"-datadir={BITCOIND_DATADIR}",
+        "-server",
+        "-fallbackfee=0.0002",
+        "-rpcbind=127.0.0.1",
+        "-rpcallowip=127.0.0.1",
+        "-printtoconsole",
+        "-txindex"
+    ]
+
+    BITCOIND_DATADIR.mkdir(parents=True, exist_ok=True)
+
+    process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    for _ in range(30):
+        if COOKIE_PATH.exists():
+            break
+        time.sleep(1)
+    else:
+        process.terminate()
+        raise RuntimeError("bitcoind did not create cookie file in time")
+
+    return process, BITCOIND_DATADIR
+
+
+def get_cookie_auth():
+    for _ in range(30):
+        if COOKIE_PATH.exists():
+            with open(COOKIE_PATH) as f:
+                cookie = f.read().strip()
+            return f"http://{cookie}@127.0.0.1:18443"
+        time.sleep(1)
+    raise RuntimeError("bitcoind cookie not found after timeout")
+
+def wait_for_bitcoind(rpc_url, timeout=30):
+    client = Proxy(rpc_url)
+    for _ in range(timeout):
+        try:
+            client._call("getblockchaininfo")
+            return client
+        except Exception as e:
+            print(f"Wanting for bitcoind: {e}")
+            time.sleep(1)
+    raise RuntimeError("bitcoind RPC not ready after timeout")
+
+def init_bitcoind_sender_receiver():
+    process, datadir = init_bitcoind()
+    rpc_url = get_cookie_auth()
+
+    wait_for_bitcoind(rpc_url)
+
+    wallet_names = ["receiver", "sender"]
+    clients = []
+
+    for wallet_name in wallet_names:
+        default_client = Proxy(rpc_url)
+        create_and_load_wallet(default_client, wallet_name)
+        wallet_client = Proxy(f"{rpc_url}/wallet/{wallet_name}")
+        clients.append(wallet_client)
+        wallet_client._call("generatetoaddress", 1, wallet_client._call("getnewaddress"))
+
+    receiver, sender = clients
+    return process, receiver, sender, datadir
+
 def create_and_load_wallet(rpc_connection, wallet_name):
     try:
         # Try to load the wallet using the _call method
@@ -44,22 +126,11 @@ def create_and_load_wallet(rpc_connection, wallet_name):
         # Check if the error code indicates the wallet does not exist
         if e.error["code"] == -18:  # Wallet not found error code
             # Create the wallet since it does not exist using the _call method
-            rpc_connection._call("createwallet", wallet_name)
-            print(f"Wallet '{wallet_name}' created and loaded successfully.")
+             rpc_connection._call("createwallet", wallet_name)
+             print(f"Wallet '{wallet_name}' created and loaded successfully.")
         elif e.error["code"] == -35:  # Wallet already loaded
             print(f"Wallet '{wallet_name}' created and loaded successfully.")
 
-
-# Set up RPC connections
-rpc_user = os.environ.get("RPC_USER", "admin1")
-rpc_password = os.environ.get("RPC_PASSWORD", "123")
-rpc_host = os.environ.get("RPC_HOST", "localhost")
-rpc_port = os.environ.get("RPC_PORT", "18443")
-#ensure this is where your access cookie is located
-rpc_data_dir = os.environ.get("RPC_DATA_DIR", "~/.bitcoin/regtest") 
-cookie_path = os.path.expanduser(os.path.join(rpc_data_dir, ".cookie"))
-rpc_user, rpc_password = get_rpc_credentials_from_cookie(cookie_path)
-
 class InMemoryReceiverPersister(ReceiverPersister):
     def __init__(self):
         super().__init__()
@@ -94,26 +165,22 @@ def load(self, token: SenderToken) -> Sender:
 class TestPayjoin(unittest.IsolatedAsyncioTestCase):
     @classmethod
     def setUpClass(cls):
-        # Initialize wallets once before all tests
-        sender_wallet_name = "sender"
-        sender_rpc_url = f"http://{rpc_user}:{rpc_password}@{rpc_host}:{rpc_port}/wallet/{sender_wallet_name}"
-        cls.sender = Proxy(service_url=sender_rpc_url)
-        create_and_load_wallet(cls.sender, sender_wallet_name)
-        cls.sender.generatetoaddress(1, cls.sender.getnewaddress())
-
-        receiver_wallet_name = "receiver"
-        receiver_rpc_url = f"http://{rpc_user}:{rpc_password}@{rpc_host}:{rpc_port}/wallet/{receiver_wallet_name}"
-        cls.receiver = Proxy(service_url=receiver_rpc_url)
-        create_and_load_wallet(cls.receiver, receiver_wallet_name)
-        cls.receiver.generatetoaddress(1, cls.receiver.getnewaddress())
+        cls.process, cls.receiver, cls.sender, cls.data_dir = init_bitcoind_sender_receiver()
 
+    @classmethod
+    def tearDownClass(cls):
+        if hasattr(cls, "process") and cls.process.poll() is None:
+            cls.process.terminate()
+            cls.process.wait()
+
+        if BITCOIND_DATADIR.exists():
+            shutil.rmtree(BITCOIND_DATADIR)
+
     async def test_integration_v2_to_v2(self):
         try:
             receiver_address = bitcoinffi.Address(str(self.receiver.getnewaddress()), bitcoinffi.Network.REGTEST)
             init_tracing()
             self.receiver.generatetoaddress(101, bitcoinffi.Address("mz3QWUnL94q2RdRxFtPq747SngoBu5uQMi", bitcoinffi.Network.REGTEST))
-            pre_payjoin_receiver_balance = self.receiver.getbalance()
-            pre_payjoin_sender_balance = self.sender.getbalance()
             services = TestServices.initialize()
 
             services.wait_for_services_ready()
@@ -145,8 +212,6 @@ async def test_integration_v2_to_v2(self):
             # Inside the Sender:
             # Create a funded PSBT (not broadcasted) to address with amount given in the pj_uri
             pj_uri = session.pj_uri()
-            outputs = {}
-            outputs[pj_uri.address()] = 0.0001
             psbt = build_sweep_psbt(self.sender, pj_uri)
             new_sender = SenderBuilder(psbt, pj_uri).build_recommended(1000)
             persister = InMemorySenderPersister()
@@ -201,16 +266,14 @@ async def test_integration_v2_to_v2(self):
             final_psbt = self.sender._call("finalizepsbt", payjoin_psbt, False)["psbt"]
             payjoin_tx = bitcoinffi.Psbt.deserialize_base64(final_psbt).extract_tx()
             self.sender.sendrawtransaction(payjoin_tx)
-            # print(f"Tx sent: {payjoin_tx.compute_txid()}")
-            self.receiver.generatetoaddress(1, bitcoinffi.Address("mz3QWUnL94q2RdRxFtPq747SngoBu5uQMi", bitcoinffi.Network.REGTEST))
 
             # Check resulting transaction and balances
-            network_fees = bitcoinffi.Psbt.deserialize_base64(final_psbt).fee().to_sat()
+            network_fees = bitcoinffi.Psbt.deserialize_base64(final_psbt).fee().to_btc()
             # Sender sent the entire value of their utxo to receiver (minus fees)
             self.assertEqual(len(payjoin_tx.input()), 2);
-            self.assertEqual(len(payjoin_tx.output()), 2);
-            self.assertEqual(self.receiver.getbalance(), pre_payjoin_receiver_balance + 10000)
-            self.assertEqual(self.sender.getbalance(), pre_payjoin_sender_balance - (10000 + network_fees))
+            self.assertEqual(len(payjoin_tx.output()), 1);
+            self.assertEqual(float(self.receiver._call("getbalances")["mine"]["untrusted_pending"]), 100 - network_fees)
+            self.assertEqual(self.sender.getbalance(), 0)
             return
         except Exception as e:
             print("Caught:", e)
@@ -227,13 +290,13 @@ def handle_directory_payjoin_proposal(receiver: Proxy, proposal: UncheckedPropos
 
 def build_sweep_psbt(sender: Proxy, pj_uri: PjUri) -> bitcoinffi.Psbt:
     outputs = {}
-    outputs[pj_uri.address()] = 0.0001
+    outputs[pj_uri.address()] = 49.99998318
     psbt = sender._call(
         "walletcreatefundedpsbt",
         [],
         outputs,
         0,
-        {"lockUnspents": True, "fee_rate": 10, "subtract_fee_from_outputs": [0]},
+        {"lockUnspents": True, "fee_rate": 10, "subtract_fee_from_outputs": [0]}
         )["psbt"]
     return sender._call("walletprocesspsbt", psbt, True, None, False)["psbt"]