Test related files (may delete some after PR review).

Author: phil-markarian

bsv/fee_models/live_policy.py

@@ -7,9 +7,8 @@
 from dataclasses import dataclass
 from typing import Optional, Tuple
 
-import requests
-
 from ..constants import HTTP_REQUEST_TIMEOUT
+from ..http_client import default_http_client
 from .satoshis_per_kilobyte import SatoshisPerKilobyte
 
 
@@ -89,19 +88,19 @@ def get_instance(
                     )
         return cls._instance
 
-    def compute_fee(self, tx) -> int:  # type: ignore[override]
+    async def compute_fee(self, tx) -> int:  # type: ignore[override]
         """Compute a fee for ``tx`` using the latest ARC rate."""
-        rate = self.current_rate_sat_per_kb()
+        rate = await self.current_rate_sat_per_kb()
         self.value = rate
         return super().compute_fee(tx)
 
-    def current_rate_sat_per_kb(self) -> int:
+    async def current_rate_sat_per_kb(self) -> int:
         """Return the cached sat/kB rate or fetch a new value from ARC."""
         cache = self._get_cache(allow_stale=True)
         if cache and self._cache_valid(cache):
             return cache.value
 
-        rate, error = self._fetch_sat_per_kb()
+        rate, error = await self._fetch_sat_per_kb()
         if rate is not None:
             self._set_cache(rate)
             return rate
@@ -143,20 +142,24 @@ def _set_cache(self, value: int) -> None:
         with self._cache_lock:
             self._cache = _CachedRate(value=value, fetched_at_ms=time.time() * 1000)
 
-    def _fetch_sat_per_kb(self) -> Tuple[Optional[int], Optional[Exception]]:
+    async def _fetch_sat_per_kb(self) -> Tuple[Optional[int], Optional[Exception]]:
         """Fetch the latest fee policy from ARC and coerce it to sat/kB."""
         try:
             headers = {"Accept": "application/json"}
             if self.api_key:
                 headers["Authorization"] = self.api_key
 
-            response = requests.get(
+            http_client = default_http_client()
+            response = await http_client.get(
                 self.arc_policy_url,
                 headers=headers,
                 timeout=self.request_timeout,
             )
-            response.raise_for_status()
-            payload = response.json()
+            payload = response.json_data
+            if isinstance(payload, dict) and "data" in payload:
+                data_section = payload.get("data")
+                if isinstance(data_section, dict):
+                    payload = data_section
         except Exception as exc:
             return None, exc
 

bsv/http_client.py

@@ -19,15 +19,27 @@ def __init__(self, ok: bool, status_code: int, json_data: dict):
     def json(self):
         return self._json_data
 
+    @property
+    def json_data(self):
+        return self._json_data
+
 
 class DefaultHttpClient(HttpClient):
     async def fetch(self, url: str, options: dict) -> HttpResponse:
+        timeout_value = options.get("timeout")
+        aiohttp_timeout = (
+            aiohttp.ClientTimeout(total=timeout_value)
+            if timeout_value is not None
+            else None
+        )
+
         async with aiohttp.ClientSession() as session:
             async with session.request(
                 method=options["method"],
                 url=url,
                 headers=options.get("headers", {}),
                 json=options.get("data", None),
+                timeout=aiohttp_timeout,
             ) as response:
                 try:
                     json_data = await response.json()
@@ -45,6 +57,34 @@ async def fetch(self, url: str, options: dict) -> HttpResponse:
                         json_data={},
                     )
 
+    async def get(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> HttpResponse:
+        options = {
+            "method": "GET",
+            "headers": headers or {},
+            "timeout": timeout,
+        }
+        return await self.fetch(url, options)
+
+    async def post(
+        self,
+        url: str,
+        data: Optional[dict] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> HttpResponse:
+        options = {
+            "method": "POST",
+            "headers": headers or {},
+            "data": data,
+            "timeout": timeout,
+        }
+        return await self.fetch(url, options)
+
 class SyncHttpClient(HttpClient):
     """Synchronous HTTP client compatible with DefaultHttpClient"""
 
@@ -137,4 +177,4 @@ def default_sync_http_client() -> SyncHttpClient:
 
 
 def default_http_client() -> HttpClient:
-    return DefaultHttpClient()
+    return DefaultHttpClient()

bsv/transaction.py

@@ -1,3 +1,5 @@
+import asyncio
+import inspect
 import math
 from contextlib import suppress
 from typing import List, Optional, Union, Dict, Any
@@ -184,16 +186,31 @@ def fee(self, model_or_fee=None, change_distribution='equal'):
             )
 
         if isinstance(model_or_fee, int):
-            fee = model_or_fee
-        else:
-            fee = model_or_fee.compute_fee(self)
+            return self._apply_fee_amount(model_or_fee, change_distribution)
+
+        fee_estimate = model_or_fee.compute_fee(self)
+
+        if inspect.isawaitable(fee_estimate):
+            async def _resolve_and_apply():
+                resolved_fee = await fee_estimate
+                return self._apply_fee_amount(resolved_fee, change_distribution)
+
+            try:
+                asyncio.get_running_loop()
+            except RuntimeError:
+                return asyncio.run(_resolve_and_apply())
+            else:
+                return _resolve_and_apply()
 
+        return self._apply_fee_amount(fee_estimate, change_distribution)
+
+    def _apply_fee_amount(self, fee: int, change_distribution: str):
         change = 0
         for tx_in in self.inputs:
             if not tx_in.source_transaction:
                 raise ValueError('Source transactions are required for all inputs during fee computation')
             change += tx_in.source_transaction.outputs[tx_in.source_output_index].satoshis
-        
+
         change -= fee
 
         change_count = 0
@@ -218,6 +235,7 @@ def fee(self, model_or_fee=None, change_distribution='equal'):
             for out in self.outputs:
                 if out.change:
                     out.satoshis = per_output
+        return None
 
     async def broadcast(
             self,

create_wallet.py

@@ -0,0 +1,36 @@
+from bsv import PrivateKey
+
+
+def main():
+    """
+    Generates a new BSV sender and receiver wallet and saves the info to wallet_info.txt.
+    """
+    # Generate sender address (Address A)
+    priv_key_a = PrivateKey()
+    wif_a = priv_key_a.wif()  # Wallet Import Format
+    address_a = priv_key_a.address()
+
+    # Generate receiver address (Address B)
+    priv_key_b = PrivateKey()
+    wif_b = priv_key_b.wif()
+    address_b = priv_key_b.address()
+
+    # Print out the keys and addresses
+    print("\n===== SENDER INFORMATION =====")
+    print(f"Private Key: {wif_a}")
+    print(f"Address: {address_a}")
+
+    print("\n===== RECEIVER INFORMATION =====")
+    print(f"Private Key: {wif_b}")
+    print(f"Address: {address_b}")
+
+    # Save data to file for easy reference
+    with open("wallet_info.txt", "w") as f:
+        f.write(f"Sender Private Key: {wif_a}\n")
+        f.write(f"Sender Address: {address_a}\n\n")
+        f.write(f"Receiver Private Key: {wif_b}\n")
+        f.write(f"Receiver Address: {address_b}\n")
+    print("\nThis information has been saved to wallet_info.txt")
+
+if __name__ == "__main__":
+    main()

inspect_live_policy.py

@@ -0,0 +1,30 @@
+import asyncio
+import json
+import logging
+
+from bsv.fee_models.live_policy import LivePolicy
+from bsv.http_client import default_http_client
+
+
+async def main() -> None:
+    logging.basicConfig(level=logging.INFO)
+    logging.getLogger("bsv.fee_models.live_policy").setLevel(logging.DEBUG)
+
+    policy = LivePolicy(cache_ttl_ms=0)
+    live_rate = await policy.current_rate_sat_per_kb()
+    print(f"Live fee rate: {live_rate} sat/kB")
+
+    http_client = default_http_client()
+    response = await http_client.get(
+        policy.arc_policy_url,
+        headers={"Accept": "application/json"},
+        timeout=policy.request_timeout,
+    )
+    print(f"HTTP status: {response.status_code}")
+    payload = response.json_data
+    print("Policy payload:")
+    print(json.dumps(payload, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

live_test.py

@@ -0,0 +1,95 @@
+import asyncio
+import logging
+from bsv import (
+    PrivateKey, P2PKH, Transaction, TransactionInput, TransactionOutput
+)
+from bsv.fee_models.live_policy import LivePolicy
+from bsv.keys import PublicKey
+
+logging.basicConfig(level=logging.INFO)
+logging.getLogger("bsv.fee_models.live_policy").setLevel(logging.DEBUG)
+
+async def main():
+    """
+    A live test script to send BSV.
+
+    Instructions:
+    1. Fund the SENDER_WIF with some BSV. You can get a WIF from a new wallet or use one you have.
+    2. Go to a block explorer like https://whatsonchain.com and find a transaction
+       where you received funds to the sender's address.
+    3. Copy the 'raw transaction hex' of that transaction and paste it into SOURCE_TX_HEX.
+    4. Update SOURCE_OUTPUT_INDEX to the correct index (usually 0 or 1) that corresponds
+       to the UTXO you want to spend.
+    5. Run the script: `python live_test.py`
+    """
+
+    # --- CONFIGURATION - PLEASE EDIT THESE VALUES ---
+
+    # 1. The private key of the wallet that has funds.
+    #    You can generate one using create_wallet.py, or use an existing one.
+    SENDER_WIF = "Kwr1hjXs7E9uCKknaKLXDHoKMLZ37EbnNU7b4bHx6qLh2tPiwkNf"
+
+    # 2. The address you want to send BSV to.
+    RECIPIENT_ADDRESS = "1CaS8TVYPWdGhHukE3Q1nxqN1NMPQYUUnJ" # The address from your wallet_info.txt
+
+    # 3. The raw hex of a transaction where you received BSV to the SENDER_WIF address.
+    SOURCE_TX_HEX = '010000000309c18e11424ab71674d4bc9e390cc928ed27c001316ea607e6abd8e5fd996849010000006a473044022061b06684612b3d72e824430d93ccf09b04cd6872f5f116ea3214565938ecb0d802203178f8ecca4146852adee9ff5d8078aeb4fb9412c24cfe2694bcd9e3edd18de6412102a773b3a312dc7e0488d978b4fb2089ef466780cbdb639c49af97ffe06fca671cffffffff3bc3ce7935248145779ebdff453a22f9b39819155ba93bde35aba7944a8a64d4030000006a473044022033b1a478bd834349abb768e788dbbebd44f71bbe3bc618f689cd9e7c2defb35f022032582013de69e4fb62ad90b2a0299f21e76956f01032399ef3bc1445cf15331e41210387c8dc9c38330bec6118692b864da8f2a18e6cc732ba106c0d803dfbc74932ccffffffff3bc3ce7935248145779ebdff453a22f9b39819155ba93bde35aba7944a8a64d4040000006a473044022061d20e11129c9c4beb5eeee26652de855614011e05b2aa28b5f2b00a571c4fe902205c6795d9461a1d409c54b1586237d7f9f8ca5b847dbb6200ebb7e7a5dc16d9d141210387c8dc9c38330bec6118692b864da8f2a18e6cc732ba106c0d803dfbc74932ccffffffff02f59e0000000000001976a9146d2d67bed1863b2e39794df441532b5ed02f136588ac5b240000000000001976a914e2d61c65f720d6f8020b5211c3945f65ad7da3f988ac00000000'  # From https://whatsonchain.com/tx/831e5b10660ff612ec3a0f0ae15cc74573366c7423ee7efbe94a457b30a7f323
+
+    # 4. The output index from the source transaction that you want to spend.
+    SOURCE_OUTPUT_INDEX = 0  # This is the output that sent funds to 1AxH3ishqURaeNUvuQoqNQXELdDyBti52v
+
+    # 5. Amount to send in satoshis (1 BSV = 100,000,000 satoshis)
+    SATOSHIS_TO_SEND = 500  # A small amount for a test
+
+    # --- END OF CONFIGURATION ---
+
+    if "L1xx" in SENDER_WIF or "0100000001xx" in SOURCE_TX_HEX:
+        print("ERROR: Please update the SENDER_WIF and SOURCE_TX_HEX variables in the script.")
+        return
+
+    sender_priv_key = PrivateKey(SENDER_WIF)
+    sender_address = sender_priv_key.address()
+    print(f"\nSender Address: {sender_address}")
+
+    # Create a transaction object from the source hex
+    source_tx = Transaction.from_hex(SOURCE_TX_HEX)
+
+    # Create the transaction input from the UTXO we want to spend
+    tx_input = TransactionInput(
+        source_transaction=source_tx,
+        source_txid=source_tx.txid(),
+        source_output_index=SOURCE_OUTPUT_INDEX,
+        unlocking_script_template=P2PKH().unlock(sender_priv_key),
+    )
+
+    # Create the output to the recipient
+    tx_output_recipient = TransactionOutput(
+        locking_script=P2PKH().lock(RECIPIENT_ADDRESS),
+        satoshis=SATOSHIS_TO_SEND
+    )
+
+    # Create the change output back to the sender
+    tx_output_change = TransactionOutput(
+        locking_script=P2PKH().lock(sender_address),
+        change=True
+    )
+
+    # Build, sign, and broadcast the transaction
+    print("\nFetching live fee policy...")
+    live_policy = LivePolicy.get_instance() # Use a safer fallback rate
+    fee_rate = await live_policy.current_rate_sat_per_kb()
+    print(f"Using fee rate: {fee_rate} sat/kB")
+
+    tx = Transaction([tx_input], [tx_output_recipient, tx_output_change])
+    await tx.fee(live_policy)  # Automatically calculate fee and adjust change
+
+    tx.sign()
+
+    print(f"\nBroadcasting transaction... Raw Hex: {tx.hex()}")
+    response = await tx.broadcast()
+    print(f"Broadcast Response: {response}")
+    print(f"Transaction ID: {tx.txid()}")
+    print(f"\nCheck on WhatsOnChain: https://whatsonchain.com/tx/{tx.txid()}")
+
+if __name__ == "__main__":
+    asyncio.run(main())