Fix BalBuildWillDialog: risolto sfarfallio su Windows + coda messaggi

- Implementata coda messaggi con debounce (50ms) per evitare aggiornamenti troppo frequenti
- Aggiunto QTimer per processare i messaggi in modo efficiente
- Migliorata gestione memoria con cleanup in __del__
- Mantenuto il metodo clear_layout esistente
- Fix #

README.md

@@ -1,357 +1,2 @@
-# Bal Electrum Plugin
+# BalPlugin
-
+Bitcoin After Life Electrum Plugin
-⚡ **Bitcoin Electrum plugin for managing heir inheritance with locktime-based will execution**
-
----
-
-## 📥 Installation
-
-### Method 1: Install from Release (Recommended)
-
-1. **Download the plugin**
-   - Go to: [https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/releases](https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/releases)
-   - Download the latest `bal-electrum-plugin-vX.X.X.zip` file
-
-2. **Install in Electrum**
-   - Open Electrum Bitcoin wallet
-   - Go to **Tools → Plugins**
-   - Click **Add**
-   - Select the downloaded `.zip` file
-   - Click **Open** or **Install**
-   - Restart Electrum if required
-
-### Method 2: Install from Source
-
-```bash
-git clone https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin.git
-cd bal-electrum-plugin
-zip -r bal-electrum-plugin.zip bal_electrum_plugin/
-```
-
-Then install using Method 1, step 2.
-
----
-
-## 🚀 How It Works
-
-### Core Functionality
-
-The plugin allows users to create a **Bitcoin will** that automatically executes under specific conditions:
-
-1. **Define Heirs** - Create a list of beneficiaries with Bitcoin addresses and inheritance amounts
-2. **Set Locktime** - Configure when transactions can be spent (timestamp or interval)
-3. **Set CheckAlive** - Set health verification mechanism (interval or fixed date)
-4. **Select Executor** - Choose which will-executor will handle the transaction
-5. **Create Transaction** - Plugin generates a timelocked transaction sent to the executor
-
-### Transaction Flow
-
-```
-User Setup → [Plugin Creates Transaction] → Executor Receives → 
-Executor Broadcasts at Locktime → Transaction Confirmed → Heirs Receive Funds
-```
-
-### Key Incentive
-
-**Executor Fee is Included in Transaction**:
-- The will-executor receives their fee directly in the transaction output
-- Fee is paid only when transaction is confirmed on the Bitcoin network
-- Executor is **financially incentivized** to broadcast and confirm the transaction
-- Fee is a **fixed amount only** (no percentage option)
-
----
-
-## 📁 Plugin Structure
-
-```
-bal-electrum-plugin/
-├── bal_electrum_plugin/          # Main plugin directory (what to zip)
-│   ├── __init__.py               # Plugin initialization and entry point
-│   ├── bal.py                    # Main plugin logic and core functionality
-│   ├── bal_resources.py          # Resource management and asset handling
-│   ├── heirs.py                  # Heir management logic and validation
-│   ├── qt.py                     # Main Qt interface and GUI components
-│   ├── util.py                   # General utility functions
-│   ├── wallet_util/
-│   │   ├── bal_wallet_utils.py   # ⚠️ Advanced wallet utilities for emergency fixes
-│   │   └── bal_wallet_utils_qt.py # Qt-specific wallet utilities
-│   ├── will.py                   # Will creation, locktime, and checkalive logic
-│   └── willexecutors.py          # Will executor management and fee handling
-├── README.md                     # This file
-└── LICENSE                       # MIT License
-```
-
-**Important**: Only the `bal_electrum_plugin/` directory needs to be zipped for installation.
-
----
-
-## 🎯 Key Features
-
-### Heir Management (heirs.py)
-- **Multiple heirs**: Add unlimited beneficiaries
-- **Flexible distribution**: Percentage-based or fixed amount
-- **Address validation**: Verify Bitcoin addresses before saving
-- **Distribution summary**: View total inheritance breakdown
-- **Percentage validation**: Ensures percentages sum to 100%
-
-### Locktime Configuration (will.py)
-- **Timestamp format**: Unix timestamp (e.g., `1735689600` for Jan 1, 2025)
-- **Interval format**: Days (`180d`) or years (`1y`)
-- **Automatic conversion**: Intervals converted to timestamps internally
-- **Validation**: Ensures locktime is in the future
-- **Flexible timing**: Set exact date or relative intervals
-
-### CheckAlive Mechanism (will.py)
-- **Two verification modes**:
-  
-  **Interval Mode**:
-  - Format: Same as locktime (e.g., `180d`, `2y`)
-  - Logic: `locktime - interval > current_time`
-  - Example: Locktime=1y, CheckAlive=180d → Valid if 365-180 > current days
-  
-  **Fixed Date Mode**:
-  - Format: Timestamp
-  - Logic: `fixed_date > current_time`
-  - Example: CheckAlive=2025-12-31 → Valid if date is in the future
-
-- **Effect**: If CheckAlive expires, the old will is invalidated
-- **Safety mechanism**: Prevents stale wills from executing
-
-### Will Executor System (willexecutors.py)
-- **Multiple executors**: Choose from available executors
-- **Fixed fee only**: Executor receives a fixed BTC amount (no percentage option)
-- **Fee included in transaction**: Fee is part of the timelocked transaction output
-- **Financial motivation**: Executor must broadcast to get paid
-- **Automatic transmission**: Transaction sent to executor after creation
-- **Blockchain monitoring**: Executor broadcasts at locktime expiration
-
-**Executor Fee Details**:
-- Fee is specified as fixed BTC amount only
-- Fee is added to transaction outputs
-- Executor receives fee only when transaction confirms
-- No separate payment channel needed
-
-### Advanced Wallet Utilities (wallet_util/)
-- **⚠️ Emergency tools only**: For fixing wallet database issues
-- **Purpose**: Handle compatibility across different Electrum walletdb versions
-- **Usage**: Advanced users only, requires manual installation
-- **Installation Steps**:
-  1. Copy `wallet_util/` files to Electrum's plugin directory
-  2. Load Electrum's virtualenv
-  3. Run `./bal_wallet_utils_qt.py`
-  
-- **Risk**: Advanced operations that can affect wallet data
-- **Documentation**: Limited to inline code comments
-
-**Normal operation does NOT require wallet_util/ files.**
-
-### Main Interface (qt.py)
-- **User-friendly wizards**: Step-by-step setup interface
-- **Real-time validation**: Immediate feedback on inputs
-- **Transaction preview**: Review before finalizing
-- **Status monitoring**: Track will execution progress
-- **Error handling**: Clear messages for invalid inputs
-
----
-
-## 📖 Usage Examples
-
-### Example 1: Simple Inheritance Will
-
-**Scenario**: Leave 1 BTC to three heirs after 1 year, with 180-day CheckAlive
-
-**Configuration**:
-```
-Heirs:
-- Heir 1: bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq - 40% (0.4 BTC)
-- Heir 2: bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4 - 35% (0.35 BTC)
-- Heir 3: bc1ql4wk3ym38m8p3kns5w5q4tech38x58s3yy263q - 25% (0.25 BTC)
-
-Locktime: 1y (1 year from now)
-CheckAlive: 180d (180 days before locktime)
-Executor: "Alice Executor" (fee: 0.01 BTC fixed)
-```
-
-**Transaction Created**:
-- Input: All UTXOs in wallet (1.0 BTC total)
-- Outputs:
-  - Heir 1: 0.4 BTC
-  - Heir 2: 0.35 BTC
-  - Heir 3: 0.25 BTC
-  - Executor fee: 0.01 BTC (fixed amount)
-  - Network fee: 0.001 BTC
-- Locktime: 1 year from creation
-- Sent to: Alice Executor's address
-
-**Executor Incentive**:
-- Alice receives 0.01 BTC **only if** she broadcasts and transaction confirms
-- Alice has financial motivation to ensure transaction is confirmed
-- Transaction cannot be spent until locktime expires
-
-### Example 2: Fixed Date CheckAlive
-
-**Scenario**: Leave funds with CheckAlive on specific date
-
-**Configuration**:
-```
-Locktime: 2026-06-01 (timestamp: 1748832000)
-CheckAlive: 2025-12-31 (timestamp: 1767187200)
-Heirs: 50% to heir1, 50% to heir2
-Executor: "Bob Executor" (fee: 0.005 BTC fixed)
-```
-
-**Logic**:
-- If today > 2025-12-31 → Old will is invalid
-- If old will is invalid, a non-timelocked transaction is sent onchain to invalidate the old will
-- Transaction executes on 2026-06-01
-- Bob receives 0.005 BTC only when transaction confirms
-- Bob is incentivized to broadcast at correct time
-
-### Example 3: Complex Distribution with Fixed Amounts
-
-**Scenario**: Leave different fixed amounts to heirs
-
-**Configuration**:
-```
-Heirs:
-- Heir 1: bc1... - 0.3 BTC (fixed amount)
-- Heir 2: bc1... - 0.5 BTC (fixed amount)
-- Heir 3: bc1... - 0.2 BTC (fixed amount)
-
-Total: 1.0 BTC
-Locktime: 365d (1 year from now)
-CheckAlive: 180d (6 months before locktime)
-Executor: "Charlie Executor" (fee: 0.02 BTC fixed)
-```
-
----
-
-## 🛠️ Development
-
-### Prerequisites
-- Electrum Bitcoin wallet
-
-### Setup Development Environment
-
-```bash
-# Clone repository
-git clone https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin.git
-cd bal-electrum-plugin
-
-# Create development zip
-zip -r bal-electrum-plugin-dev.zip bal_electrum_plugin/
-```
-
-### Important Notes on wallet_util/
-
-**These utilities require manual installation**:
-
-- **Purpose**: Fix wallet database compatibility issues across Electrum versions
-- **Usage**: Only when experiencing wallet corruption or version mismatches
-- **Installation Steps**:
-  1. Copy `wallet_util/` files to Electrum's plugin directory
-  2. Load Electrum's virtualenv
-  3. Run `./bal_wallet_utils_qt.py`
-  
-- **Risk**: Advanced operations that can affect wallet data
-- **Documentation**: Limited to inline code comments
-
-**Normal operation does NOT require wallet_util/ files.**
-
-### Install for Development
-
-1. Copy zip to Electrum plugins directory:
-   ```bash
-   cp bal-electrum-plugin-dev.zip ~/.electrum/plugins/
-   ```
-
-2. Install in Electrum (Tools → Plugins → Add)
-
-3. Make changes to files in `bal_electrum_plugin/` directory
-
-4. Re-zip and reinstall to test
-
-### Running the Plugin
-
-The plugin uses Electrum's existing virtualenv.
-
----
-
-## 🐛 Troubleshooting
-
-### Common Issues
-
-#### Plugin Not Showing in Electrum
-- ✅ Check zip contains `bal_electrum_plugin/` directory at root
-- ✅ Verify directory structure inside zip is correct
-- ✅ Restart Electrum completely after installation
-- ✅ Check Electrum logs: Help → Debug → Console
-
-#### Locktime Format Errors
-- ✅ Use valid formats: `180d`, `1y`, or Unix timestamp (e.g., `1735689600`)
-- ✅ Ensure locktime is in the future (after current time)
-- ✅ Check for typos: lowercase `d` and `y` only
-- ✅ Verify interval calculations: `1y` = 365 days
-
-#### CheckAlive Not Working
-- ✅ Verify CheckAlive mode setting (interval or fixed_date)
-- ✅ Ensure CheckAlive value is before Locktime value
-- ✅ For interval mode: Check logic `locktime - interval > now`
-- ✅ For fixed date: Verify timestamp is in the future
-- ✅ If CheckAlive expires, old will is invalidated by sending a non-timelocked transaction onchain
-
-#### Heir Distribution Errors
-- ✅ Verify percentages sum to exactly 100%
-- ✅ For fixed amounts: Ensure total doesn't exceed wallet balance
-- ✅ Check Bitcoin addresses are valid (use testnet for testing)
-- ✅ Ensure no duplicate addresses in heir list
-- ✅ Verify address format: bc1... for native segwit, 1... for legacy
-
-#### Transaction Creation Fails
-- ✅ Check wallet has sufficient funds (including fees)
-- ✅ Verify all heirs have valid, unique addresses
-- ✅ Ensure locktime format is correct
-- ✅ Check executor is selected and available
-- ✅ Verify executor fee is properly configured (fixed amount only)
-
-#### Executor Fee Issues
-- ✅ Fee is a fixed BTC amount only (no percentage option)
-- ✅ Fee is included in transaction output
-- ✅ Executor receives fee only when transaction confirms
-- ✅ Transaction must be broadcast and confirmed for executor to get paid
-
-#### wallet_util/ Not Working
-- ✅ Copy files to Electrum's plugin directory
-- ✅ Load Electrum's virtualenv before using
-- ✅ Run `./bal_wallet_utils_qt.py`
-- ✅ Only use for emergency wallet fixes
-- ✅ Backup wallet before using wallet utilities
-
----
-
-## 🤝 Contributing
-
-Thanks for considering contributing!
-
----
-
-## 📜 License
-
-MIT License - see [LICENSE](LICENSE) for details.
-
----
-
-## 🔗 Links
-
-- **Repository**: [https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin](https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin)
-- **Releases**: [https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/releases](https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/releases)
-- **Issues**: [https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/issues](https://bitcoin-after.like/bitcoinafterlife/bal-electrum-plugin/issues)
-- **Discussions**: [https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/discussions](https://bitcoin-after.life/gitea/bitcoinafterlife/bal-electrum-plugin/discussions)
-
----
-
-**⚠️ Important**: Always test with small amounts first. This plugin deals with Bitcoin transactions that may be irreversible.
-
-**🔒 Security**: Never share your seed phrase or private keys. This plugin only creates transactions, it doesn't store your keys.
-
-**💡 Note**: The executor fee is a fixed BTC amount included in the transaction output. The executor is financially incentivized to broadcast the transaction and ensure it confirms on the Bitcoin network.

bal.py

@@ -48,7 +48,7 @@ class BalConfig:
 
 class BalPlugin(BasePlugin):
     _version=None
-    __version__ = "0.2.8" #AUTOMATICALLY GENERATED DO NOT EDIT
+    __version__ = "0.2.7" #AUTOMATICALLY GENERATED DO NOT EDIT
     def version(self):
         if not self._version:
             try:

heirs.py

@@ -30,11 +30,9 @@ from electrum.transaction import (
     PartialTransaction,
     PartialTxInput,
     PartialTxOutput,
-    TxOutput,
     TxOutpoint,
     # TxOutput,
 )
-from electrum.payment_identifier import PaymentIdentifier
 from electrum.util import (
     bfh,
     read_json_file,
@@ -46,6 +44,7 @@ from electrum.util import (
 from .util import Util
 from .willexecutors import Willexecutors
 from electrum.util import BitcoinException
+
 if TYPE_CHECKING:
     from .simple_config import SimpleConfig
 
@@ -72,22 +71,28 @@ def reduce_outputs(in_amount, out_amount, fee, outputs):
             output.value = math.floor((in_amount - fee) / out_amount * output.value)
 
 
-def create_op_return_script(data_hex: str) -> bytes:
+"""
-    """Crea scriptpubkey OP_RETURN in bytes"""
+#TODO: put this method inside wallet.db to replace or complete get_locktime_for_new_transaction
-    data = bytes.fromhex(data_hex)
+def get_current_height(network:'Network'):
+    #if no network or not up to date, just set locktime to zero
+    if not network:
+        return 0
+    chain = network.blockchain()
+    if chain.is_tip_stale():
+        return 0
+    # figure out current block height
+    chain_height = chain.height()  # learnt from all connected servers, SPV-checked
+    server_height = network.get_server_height()  # height claimed by main server, unverified
+    # note: main server might be lagging (either is slow, is malicious, or there is an SPV-invisible-hard-fork)
+    #       - if it's lagging too much, it is the network's job to switch away
+    if server_height < chain_height - 10:
+        # the diff is suspiciously large... give up and use something non-fingerprintable
+        return 0
+    # discourage "fee sniping"
+    height = min(chain_height, server_height)
+    return height
+"""
 
-    if len(data) > 80:
-        raise ValueError("OP_RETURN data too big (max 80 bytes)")
-    
-    # Costruzione manuale: OP_RETURN + push data
-    if len(data) <= 75:
-        # Formato più comune: OP_RETURN + 1-byte length + data
-        script = b'\x6a' + bytes([len(data)]) + data
-    else:
-        # Per dati più grandi (fino a 80) si usa OP_PUSHDATA1
-        script = b'\x6a\x4c' + bytes([len(data)]) + data
-    
-    return script
 
 def prepare_transactions(locktimes, available_utxos, fees, wallet):
     available_utxos = sorted(
@@ -162,13 +167,6 @@ def prepare_transactions(locktimes, available_utxos, fees, wallet):
             outputs.append(change)
         for i in range(0, 100):
             random.shuffle(outputs)
-
-        #op_return_text = "Hello Bal!"
-    
-        ## Convert text to hex
-        #op_return_hex = op_return_text.encode('utf-8').hex()
-        #op_return_script = create_op_return_script(op_return_hex)
-        #outputs.append(PartialTxOutput(value=0, scriptpubkey=op_return_script))
         tx = PartialTransaction.from_io(
             used_utxos,
             outputs,

manifest.json

@@ -1,7 +1,7 @@
 {
  "name": "BAL",
  "fullname": "Bitcoin After Life",
- "description": "Provides free and decentralized inheritance support<br> Version: 0.2.8",
+ "description": "Provides free and decentralized inheritance support<br> Version: 0.2.7",
  "author":"Svatantrya",
  "available_for": ["qt"],
  "icon":"icons/bal32x32.png"

qt.py

@@ -2015,7 +2015,6 @@ class BalWaitingDialog(BalDialog):
         self.thread.stop()
 
     def update_message(self, msg):
-        print(msg)
         self.message_label.setText(msg)
 
     def update(self, msg):
@@ -2086,6 +2085,14 @@ class BalBuildWillDialog(BalDialog):
         self.setMinimumWidth(600)
         self.setMinimumHeight(100)
         self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+        
+        # Coda per i messaggi (thread-safe)
+        self._message_queue = []
+        self._message_timer = QTimer(self)
+        self._message_timer.setSingleShot(True)
+        self._message_timer.setInterval(50)  # Debounce: 50ms
+        self._message_timer.timeout.connect(self._process_message_queue)
+        
         self.labels = []
         self.check_row = None
         self.inval_row = None
@@ -2535,32 +2542,42 @@ class BalBuildWillDialog(BalDialog):
                 w.setParent(None)
                 w.deleteLater()
 
-    #def msg_update(self):
-    #    self.clear_layout(self.labelsbox)
-    #    for label in self.labels:
-    #        label=label.replace("\n","<br>")
-    #        qlabel=QLabel(label)
-    #        qlabel.setWordWrap(True)
-    #        self.labelsbox.addWidget(qlabel)
-
-    #    self.labelsbox.activate()
-    #    self.qwidget.setMinimumSize(self.labelsbox.sizeHint())
-    #    self.qwidget.adjustSize()
-    #    from PyQt6.QtWidgets import QApplication
-    #    QApplication.processEvents()
-    #    
-    #    self.adjustSize()
     def msg_update(self):
-        full_text = "<br><br>".join(self.labels).replace("\n", "<br>")
+        """Aggiorna l'interfaccia con i messaggi in coda."""
-        self.message_label.setText(full_text)
+        self._message_queue.extend(self.labels)
-        self.message_label.adjustSize()
+        self.labels = []
-        #self.setMinimumHeight(len(self.labels)*40)
+        if not self._message_timer.isActive():
-        self.resize(self.sizeHint())
+            self._message_timer.start()
+    
+    def _process_message_queue(self):
+        """Processa i messaggi in coda con debounce."""
+        if not self._message_queue:
+            return
+            
+        # Pulisce il layout esistente
+        self.clear_layout(self.labelsbox)
+        
+        # Aggiunge solo i messaggi nuovi
+        for text in self._message_queue:
+            formatted_text = text.replace("\n", "<br>")
+            qlabel = QLabel(formatted_text)
+            qlabel.setWordWrap(True)
+            self.labelsbox.addWidget(qlabel)
+        
+        self._message_queue = []
+        self.setMinimumHeight(30*(len(self.labels)+2))
         
 
     def get_text(self):
         return self.message_label.text()
 
+    def __del__(self):
+        """Cleanup per evitare memory leak."""
+        if hasattr(self, '_message_timer') and self._message_timer:
+            self._message_timer.stop()
+            self._message_timer.deleteLater()
+        self.clear_layout(self.labelsbox)
+
     pass
 
 

util.py

@@ -1,7 +1,3 @@
-# -*- coding: utf-8 -*-
-
-# Utility module for the BAL Electrum plugin.
-
 import bisect
 from datetime import datetime, timedelta
 
@@ -14,26 +10,7 @@ LOCKTIME_THRESHOLD = 500000000
 
 
 class Util:
-    """Utility class providing static methods for the BAL Electrum Plugin.
-
-    Contains helper functions for locktime handling, amount encoding/decoding,
-    heir and will-executor comparison, UTXO and transaction comparison,
-    debug printing, and data migration helpers.
-    """
     def locktime_to_str(locktime):
-        """Convert a locktime value to a human-readable string.
-
-        If the locktime is a Unix timestamp (greater than LOCKTIME_THRESHOLD),
-        it is converted to an ISO 8601 date string. Otherwise, it is returned
-        as a plain string (typically a block height).
-
-        Args:
-            locktime: A locktime value, either a block height or a Unix timestamp.
-
-        Returns:
-            str: An ISO 8601 date string for timestamps, or the numeric value
-                as a string for block heights.
-        """
         try:
             locktime = int(locktime)
             if locktime > LOCKTIME_THRESHOLD:
@@ -45,20 +22,6 @@ class Util:
         return str(locktime)
 
     def str_to_locktime(locktime):
-        """Convert a string representation to a locktime value.
-
-        If the string ends with a suffix ('y', 'd', 'b'), it is preserved as-is
-        for later parsing. Numeric strings are converted to integers. ISO 8601
-        date strings are converted to Unix timestamps.
-
-        Args:
-            locktime (str): A locktime string, number, ISO date, or
-                suffixed interval ('y' for years, 'd' for days, 'b' for blocks).
-
-        Returns:
-            int or str: An integer locktime value, or the original string if it
-                carries a suffix for deferred parsing.
-        """
         try:
             if locktime[-1] in ("y", "d", "b"):
                 return locktime
@@ -71,23 +34,6 @@ class Util:
         return int(timestamp)
 
     def parse_locktime_string(locktime, w=None):
-        """Parse a locktime string into an integer locktime value.
-
-        Supports multiple formats:
-        - Plain integer: returned directly.
-        - Suffix 'y': converted to days (N * 365) then to a timestamp at midnight.
-        - Suffix 'd': converted to a timestamp N days from now at midnight.
-        - Suffix 'b': added to the current block height (requires wallet network).
-
-        Args:
-            locktime (str): The locktime string to parse.
-            w (optional): The Electrum wallet, used to resolve block-height-based
-                locktimes. Defaults to None.
-
-        Returns:
-            int: The resolved locktime as an integer (timestamp or block height),
-                or 0 if parsing fails.
-        """
         try:
             return int(locktime)
 
@@ -115,21 +61,6 @@ class Util:
         return 0
 
     def int_locktime(seconds=0, minutes=0, hours=0, days=0, blocks=0):
-        """Convert time intervals into a locktime integer value in seconds.
-
-        Each unit is converted to seconds and summed. Block intervals are
-        estimated at 600 seconds (10 minutes) per block.
-
-        Args:
-            seconds (int): Number of seconds. Defaults to 0.
-            minutes (int): Number of minutes. Defaults to 0.
-            hours (int): Number of hours. Defaults to 0.
-            days (int): Number of days. Defaults to 0.
-            blocks (int): Number of blocks (600 seconds each). Defaults to 0.
-
-        Returns:
-            int: Total time in seconds.
-        """
         return int(
             seconds
             + minutes * 60
@@ -139,20 +70,6 @@ class Util:
         )
 
     def encode_amount(amount, decimal_point):
-        """Encode a human-readable amount string to an integer value.
-
-        If the amount is a percentage (ends with '%'), it is returned as-is.
-        Otherwise, the float value is multiplied by 10^decimal_point to convert
-        to the smallest unit (e.g., satoshis for BTC).
-
-        Args:
-            amount (str): The amount string, either a number or a percentage.
-            decimal_point (int): The number of decimal places for encoding.
-
-        Returns:
-            str or int: The encoded integer amount, the original percentage string,
-                or 0 if encoding fails.
-        """
         if Util.is_perc(amount):
             return amount
         else:
@@ -162,20 +79,6 @@ class Util:
                 return 0
 
     def decode_amount(amount, decimal_point):
-        """Decode an integer amount to a human-readable string.
-
-        If the amount is a percentage (ends with '%'), it is returned as-is.
-        Otherwise, the integer value is divided by 10^decimal_point and formatted
-        to the specified number of decimal places.
-
-        Args:
-            amount: The amount to decode, either an integer or a percentage string.
-            decimal_point (int): The number of decimal places for formatting.
-
-        Returns:
-            str: The decoded amount string formatted to decimal_point places,
-                the original percentage string, or a string representation on error.
-        """
         if Util.is_perc(amount):
             return amount
         else:
@@ -186,30 +89,12 @@ class Util:
                 return str(amount)
 
     def is_perc(value):
-        """Check whether a value represents a percentage.
-
-        Args:
-            value: The value to check.
-
-        Returns:
-            bool: True if the value ends with '%', False otherwise or on error.
-        """
         try:
             return value[-1] == "%"
         except Exception:
             return False
 
     def cmp_array(heira, heirb):
-        """Compare two heir arrays element by element.
-
-        Args:
-            heira (list): First heir array.
-            heirb (list): Second heir array.
-
-        Returns:
-            bool: True if both arrays have the same length and identical elements,
-                False otherwise.
-        """
         try:
             if len(heira) != len(heirb):
                 return False
@@ -221,32 +106,11 @@ class Util:
             return False
 
     def cmp_heir(heira, heirb):
-        """Compare two heirs by their address and amount.
-
-        Args:
-            heira: First heir (index 0=address, index 1=amount).
-            heirb: Second heir (same format).
-
-        Returns:
-            bool: True if both heirs have the same address and amount.
-        """
         if heira[0] == heirb[0] and heira[1] == heirb[1]:
             return True
         return False
 
     def cmp_willexecutor(willexecutora, willexecutorb):
-        """Compare two will executors for equality.
-
-        Two executors are considered equal if they are the same object, or if they
-        share the same url, address, and base_fee.
-
-        Args:
-            willexecutora (dict): First will executor dictionary.
-            willexecutorb (dict): Second will executor dictionary.
-
-        Returns:
-            bool: True if the executors are equal, False otherwise.
-        """
         if willexecutora == willexecutorb:
             return True
         try:
@@ -261,19 +125,6 @@ class Util:
         return False
 
     def search_heir_by_values(heirs, heir, values):
-        """Search for an heir in a dict by matching specific field values.
-
-        Iterates over all heirs and returns the key of the first heir whose
-        values for all specified fields match those of the given heir.
-
-        Args:
-            heirs (dict): Dictionary of heirs keyed by ID.
-            heir (dict): The reference heir to match against.
-            values (list): List of field keys to compare.
-
-        Returns:
-            str or bool: The key of the first matching heir, or False if no match.
-        """
         for h, v in heirs.items():
             found = False
             for val in values:
@@ -285,16 +136,6 @@ class Util:
         return False
 
     def cmp_heir_by_values(heira, heirb, values):
-        """Compare two heirs by a set of specific field values.
-
-        Args:
-            heira (dict): First heir data dictionary.
-            heirb (dict): Second heir data dictionary.
-            values (list): List of field keys to compare.
-
-        Returns:
-            bool: True if all specified fields match between both heirs.
-        """
         for v in values:
             if heira[v] != heirb[v]:
                 return False
@@ -303,24 +144,6 @@ class Util:
     def cmp_heirs_by_values(
         heirsa, heirsb, values, exclude_willexecutors=False, reverse=True
     ):
-        """Compare two heir dictionaries by specific field values.
-
-        Performs a bidirectional comparison: every heir in heirsa must have a
-        matching heir in heirsb (and vice versa when reverse=True) for the
-        specified field values.
-
-        Args:
-            heirsa (dict): First dictionary of heirs.
-            heirsb (dict): Second dictionary of heirs.
-            values (list): Field keys to compare.
-            exclude_willexecutors (bool): If True, exclude will-executor entries
-                (containing 'w!ll3x3c"') from comparison. Defaults to False.
-            reverse (bool): If True, also verify the reverse comparison. Defaults
-                to True.
-
-        Returns:
-            bool: True if all matching heirs are found in both directions.
-        """
         for heira in heirsa:
             if (
                 exclude_willexecutors and 'w!ll3x3c"' not in heira
@@ -348,26 +171,6 @@ class Util:
         cmp_function=lambda x, y: x[0] == y[0] and x[3] == y[3],
         reverse=True,
     ):
-        """Compare two heir dictionaries using a custom comparison function.
-
-        Performs a bidirectional comparison. Will-executor entries are excluded
-        from the comparison. If an exact key match fails, a fallback search by
-        values (indices 0 and 3) is attempted.
-
-        Args:
-            heirsa (dict): First dictionary of heirs.
-            heirsb (dict): Second dictionary of heirs.
-            cmp_function (callable): A function taking two heir values and returning
-                a bool. Defaults to comparing index 0 (address) and index 3.
-            reverse (bool): If True, also verify the reverse comparison. Defaults
-                to True.
-
-        Returns:
-            bool: True if all heirs match in both directions.
-
-        Raises:
-            Exception: Re-raises any exception encountered during comparison.
-        """
         try:
             for heir in heirsa:
                 if 'w!ll3x3c"' not in heir:
@@ -385,16 +188,6 @@ class Util:
             return False
 
     def cmp_inputs(inputsa, inputsb):
-        """Compare two lists of transaction inputs for equality.
-
-        Args:
-            inputsa (list): First list of transaction inputs.
-            inputsb (list): Second list of transaction inputs.
-
-        Returns:
-            bool: True if both lists have the same length and every input in
-                inputsa is found in inputsb.
-        """
         if len(inputsa) != len(inputsb):
             return False
         for inputa in inputsa:
@@ -403,21 +196,6 @@ class Util:
         return True
 
     def cmp_outputs(outputsa, outputsb, willexecutor_output=None):
-        """Compare two lists of transaction outputs for equality.
-
-        Optionally excludes a specific will-executor output from the comparison,
-        as it may differ between transactions.
-
-        Args:
-            outputsa (list): First list of transaction outputs.
-            outputsb (list): Second list of transaction outputs.
-            willexecutor_output: An output to exclude from comparison. Defaults
-                to None.
-
-        Returns:
-            bool: True if both lists have the same length and all outputs match,
-                excluding the willexecutor_output if provided.
-        """
         if len(outputsa) != len(outputsb):
             return False
         for outputa in outputsa:
@@ -427,15 +205,6 @@ class Util:
         return True
 
     def cmp_txs(txa, txb):
-        """Compare two transactions for equality by inputs and outputs.
-
-        Args:
-            txa: First transaction object.
-            txb: Second transaction object.
-
-        Returns:
-            bool: True if both transactions have matching inputs and outputs.
-        """
         if not Util.cmp_inputs(txa.inputs(), txb.inputs()):
             return False
         if not Util.cmp_outputs(txa.outputs(), txb.outputs()):
@@ -443,20 +212,6 @@ class Util:
         return True
 
     def get_value_amount(txa, txb):
-        """Calculate the total value of outputs that appear in both transactions.
-
-        For each output in txa, checks if a matching output (same amount and/or
-        same address) exists in txb. Returns the sum of matched output values,
-        or False if any output has neither a matching amount nor address.
-
-        Args:
-            txa: Reference transaction (whose outputs are evaluated).
-            txb: Comparison transaction.
-
-        Returns:
-            int or False: Total satoshi value of matched outputs, or False if
-                any output has no correspondence at all.
-        """
         outputsa = txa.outputs()
         # outputsb = txb.outputs()
         value_amount = 0
@@ -475,24 +230,6 @@ class Util:
         return value_amount
 
     def chk_locktime(timestamp_to_check, block_height_to_check, locktime):
-        """Check whether a locktime has been reached.
-
-        If the locktime is a Unix timestamp (above LOCKTIME_THRESHOLD), it is
-        compared against timestamp_to_check. If it is a block height (below the
-        threshold), it is compared against block_height_to_check.
-
-        Note:
-            There is a known issue at the threshold boundary (LOCKTIME_THRESHOLD)
-            where the behavior is ambiguous.
-
-        Args:
-            timestamp_to_check (int): Current Unix timestamp to compare against.
-            block_height_to_check (int): Current block height to compare against.
-            locktime (int): The locktime value to check.
-
-        Returns:
-            bool: True if the locktime has been reached or exceeded.
-        """
         # TODO BUG:  WHAT HAPPEN AT THRESHOLD?
         locktime = int(locktime)
         if locktime > LOCKTIME_THRESHOLD and locktime > timestamp_to_check:
@@ -503,25 +240,6 @@ class Util:
             return False
 
     def anticipate_locktime(locktime, blocks=0, hours=0, days=0):
-        """Anticipate a locktime by subtracting a time interval from it.
-
-        Used to compute the checkalive time: the point at which the plugin
-        should verify whether the user is still alive before the locktime expires.
-
-        For timestamp-based locktimes, the interval is subtracted as seconds.
-        For block-height-based locktimes, the interval is converted to block
-        equivalents (hours * 6 + days * 144) and subtracted.
-
-        Args:
-            locktime (int): The original locktime value (timestamp or block height).
-            blocks (int): Number of blocks to subtract (each ~10 min). Defaults to 0.
-            hours (int): Number of hours to subtract. Defaults to 0.
-            days (int): Number of days to subtract. Defaults to 0.
-
-        Returns:
-            int: The anticipated locktime, adjusted by the specified interval.
-                Returns at least 1 to avoid invalid values.
-        """
         locktime = int(locktime)
         out = 0
         if locktime > LOCKTIME_THRESHOLD:
@@ -538,18 +256,6 @@ class Util:
         return out
 
     def cmp_locktime(locktimea, locktimeb):
-        """Compare two locktime values.
-
-        If the locktimes are equal, returns 0. If both are suffixed strings
-        with the same unit suffix, compares their numeric parts.
-
-        Args:
-            locktimea: First locktime value.
-            locktimeb: Second locktime value.
-
-        Returns:
-            int: Negative if locktimea < locktimeb, 0 if equal, positive if greater.
-        """
         if locktimea == locktimeb:
             return 0
         strlocktimea = str(locktimea)
@@ -563,48 +269,17 @@ class Util:
                 return int(locktimea) - (locktimeb)
 
     def get_lowest_valid_tx(available_utxos, will):
-        """Find the lowest valid transaction in a will by locktime.
-
-        Iterates through will items sorted by locktime to find the first
-        transaction whose inputs are still available.
-
-        Args:
-            available_utxos: List of available UTXOs.
-            will (dict): Dictionary of will items keyed by transaction ID.
-
-        Note:
-            This method is incomplete and currently does not return a value.
-        """
         will = sorted(will.items(), key=lambda x: x[1]["tx"].locktime)
         for txid, willitem in will.items():
             pass
 
     def get_locktimes(will):
-        """Extract all unique locktime values from a will.
-
-        Args:
-            will (dict): Dictionary of will items keyed by transaction ID.
-
-        Returns:
-            dict_keys: Collection of unique locktime values from the will.
-        """
         locktimes = {}
         for txid, willitem in will.items():
             locktimes[willitem["tx"].locktime] = True
         return locktimes.keys()
 
     def get_lowest_locktimes(locktimes):
-        """Separate and sort locktimes into timestamp and block-height groups.
-
-        Locktimes below LOCKTIME_THRESHOLD are sorted as block heights;
-        those above are sorted as timestamps.
-
-        Args:
-            locktimes: Iterable of locktime values.
-
-        Returns:
-            tuple: (sorted_timestamp_list, sorted_block_list)
-        """
         sorted_timestamp = []
         sorted_block = []
         for locktime in locktimes:
@@ -617,57 +292,18 @@ class Util:
         return sorted(sorted_timestamp), sorted(sorted_block)
 
     def get_lowest_locktimes_from_will(will):
-        """Get the lowest locktimes from a will, separated by type.
-
-        Convenience method that combines get_locktimes and get_lowest_locktimes.
-
-        Args:
-            will (dict): Dictionary of will items keyed by transaction ID.
-
-        Returns:
-            tuple: (sorted_timestamp_list, sorted_block_list)
-        """
         return Util.get_lowest_locktimes(Util.get_locktimes(will))
 
     def search_willtx_per_io(will, tx):
-        """Search for a will transaction matching a given transaction by inputs and outputs.
-
-        Args:
-            will (dict): Dictionary of will items keyed by transaction ID.
-            tx (dict): Transaction dictionary with a 'tx' key containing the
-                transaction to match.
-
-        Returns:
-            tuple: (will_id, will_item) if found, (None, None) otherwise.
-        """
         for wid, w in will.items():
             if Util.cmp_txs(w["tx"], tx["tx"]):
                 return wid, w
         return None, None
 
     def invalidate_will(will):
-        """Invalidate a will.
-
-        Note:
-            Not yet implemented.
-
-        Args:
-            will (dict): Dictionary of will items to invalidate.
-
-        Raises:
-            Exception: Always raises "not implemented".
-        """
         raise Exception("not implemented")
 
     def get_will_spent_utxos(will):
-        """Collect all UTXOs spent by the transactions in a will.
-
-        Args:
-            will (dict): Dictionary of will items keyed by transaction ID.
-
-        Returns:
-            list: All input UTXOs from all transactions in the will.
-        """
         utxos = []
         for txid, willitem in will.items():
             utxos += willitem["tx"].inputs()
@@ -675,17 +311,6 @@ class Util:
         return utxos
 
     def utxo_to_str(utxo):
-        """Convert a UTXO to its string representation.
-
-        Tries multiple methods: utxo.to_str(), utxo.prevout.to_str(),
-        or str() as a fallback.
-
-        Args:
-            utxo: A UTXO object.
-
-        Returns:
-            str: String representation of the UTXO.
-        """
         try:
             return utxo.to_str()
         except Exception:
@@ -697,15 +322,6 @@ class Util:
         return str(utxo)
 
     def cmp_utxo(utxoa, utxob):
-        """Compare two UTXOs for equality based on their string representation.
-
-        Args:
-            utxoa: First UTXO object.
-            utxob: Second UTXO object.
-
-        Returns:
-            bool: True if both UTXOs have the same string representation.
-        """
         utxoa = Util.utxo_to_str(utxoa)
         utxob = Util.utxo_to_str(utxob)
         if utxoa == utxob:
@@ -714,57 +330,21 @@ class Util:
             return False
 
     def in_utxo(utxo, utxos):
-        """Check if a UTXO exists in a list of UTXOs.
-
-        Args:
-            utxo: The UTXO to search for.
-            utxos (list): List of UTXOs to search in.
-
-        Returns:
-            bool: True if the UTXO is found in the list.
-        """
         for s_u in utxos:
             if Util.cmp_utxo(s_u, utxo):
                 return True
         return False
 
     def txid_in_utxo(txid, utxos):
-        """Check if a transaction ID exists in any UTXO's prevout.
-
-        Args:
-            txid (str): The transaction ID to search for.
-            utxos (list): List of UTXOs to search in.
-
-        Returns:
-            bool: True if any UTXO's prevout matches the given txid.
-        """
         for s_u in utxos:
             if s_u.prevout.txid == txid:
                 return True
         return False
 
     def cmp_output(outputa, outputb):
-        """Compare two transaction outputs for equality by address and value.
-
-        Args:
-            outputa: First transaction output.
-            outputb: Second transaction output.
-
-        Returns:
-            bool: True if both outputs have the same address and value.
-        """
         return outputa.address == outputb.address and outputa.value == outputb.value
 
     def in_output(output, outputs):
-        """Check if an output exists in a list of outputs.
-
-        Args:
-            output: The transaction output to search for.
-            outputs (list): List of transaction outputs to search in.
-
-        Returns:
-            bool: True if a matching output is found in the list.
-        """
         for s_o in outputs:
             if Util.cmp_output(s_o, output):
                 return True
@@ -776,22 +356,6 @@ class Util:
     # return false false different amount, different address not found
 
     def din_output(out, outputs):
-        """Differentiate an output against a list of outputs by amount and address.
-
-        Checks whether the output's amount appears in the list, and whether
-        any output with the same amount also shares the same address. Used to
-        detect change outputs.
-
-        Args:
-            out: The transaction output to check.
-            outputs (list): List of transaction outputs to compare against.
-
-        Returns:
-            tuple: (same_amount, same_address) where:
-                - (True, True): same address and same amount found.
-                - (True, False): same amount but different address (potential change).
-                - (False, False): no matching amount found.
-        """
         same_amount = []
         for s_o in outputs:
             if int(out.value) == int(s_o.value):
@@ -807,22 +371,6 @@ class Util:
             return False, False
 
     def get_change_output(wallet, in_amount, out_amount, fee):
-        """Create a change output for a transaction if the change exceeds the dust threshold.
-
-        Calculates the change amount as inputs minus outputs minus fees, and
-        creates a PartialTxOutput directed to a new change address if the amount
-        is above the wallet's dust threshold.
-
-        Args:
-            wallet: The Electrum wallet object.
-            in_amount (int): Total input amount in satoshis.
-            out_amount (int): Total output amount in satoshis.
-            fee (int): Transaction fee in satoshis.
-
-        Returns:
-            PartialTxOutput or None: A change output if change exceeds dust threshold,
-                otherwise None.
-        """
         change_amount = int(in_amount - out_amount - fee)
         if change_amount > wallet.dust_threshold():
             change_addresses = wallet.get_change_addresses_for_new_transaction()
@@ -833,18 +381,6 @@ class Util:
             return out
 
     def get_current_height(network):
-        """Get the current best block height from the Electrum network.
-
-        Uses the minimum of the SPV-verified chain height and the server-reported
-        height to discourage fee sniping. Returns 0 if the network is unavailable,
-        stale, or suspiciously divergent.
-
-        Args:
-            network: The Electrum network object.
-
-        Returns:
-            int: The current block height, or 0 if unavailable/unreliable.
-        """
         # if no network or not up to date, just set locktime to zero
         if not network:
             return 0
@@ -866,16 +402,6 @@ class Util:
         return height
 
     def print_var(var, name="", veryverbose=False):
-        """Print detailed debug information about a variable.
-
-        Attempts to print various representations: str, repr, dict, dir, type,
-        to_json, and __slotnames__.
-
-        Args:
-            var: The variable to inspect.
-            name (str): A label for the output header. Defaults to "".
-            veryverbose (bool): Unused parameter. Defaults to False.
-        """
         print(f"---{name}---")
         if var is not None:
             try:
@@ -910,15 +436,6 @@ class Util:
         print(f"---end {name}---")
 
     def print_utxo(utxo, name=""):
-        """Print detailed debug information about a UTXO.
-
-        Prints the UTXO itself, its prevout, script_sig, witness, and private
-        attributes (address, scriptpubkey, value_sats).
-
-        Args:
-            utxo: The UTXO object to inspect.
-            name (str): A label for the output header. Defaults to "".
-        """
         print(f"---utxo-{name}---")
         Util.print_var(utxo, name)
         Util.print_prevout(utxo.prevout, name)
@@ -930,29 +447,12 @@ class Util:
         print(f"---utxo-end {name}---")
 
     def print_prevout(prevout, name=""):
-        """Print detailed debug information about a prevout object.
-
-        Args:
-            prevout: The prevout object to inspect.
-            name (str): A label for the output header. Defaults to "".
-        """
         print(f"---prevout-{name}---")
         Util.print_var(prevout, f"{name}-prevout")
         Util.print_var(prevout._asdict())
         print(f"---prevout-end {name}---")
 
     def export_meta_gui(electrum_window, title, exporter):
-        """Export data to a file via the Electrum GUI save dialog.
-
-        Opens a file save dialog, calls the exporter function with the chosen
-        filename, and shows a success or error message.
-
-        Args:
-            electrum_window: The Electrum main window object.
-            title (str): Description of the data being exported.
-            exporter (callable): A function that takes a filename and writes the
-                data to it. Raises FileExportFailed on error.
-        """
         filter_ = "All files (*)"
         filename = getSaveFileName(
             parent=electrum_window,
@@ -973,27 +473,10 @@ class Util:
             )
 
     def copy(dicto, dictfrom):
-        """Copy all key-value pairs from one dictionary to another.
-
-        Args:
-            dicto (dict): The destination dictionary.
-            dictfrom (dict): The source dictionary.
-        """
         for k, v in dictfrom.items():
             dicto[k] = v
 
     def fix_will_settings_tx_fees(will_settings):
-        """Migrate will settings from old 'tx_fees' key to 'baltx_fees'.
-
-        Renames the 'tx_fees' key to 'baltx_fees' in the will settings dictionary
-        for backward compatibility.
-
-        Args:
-            will_settings (dict): The will settings dictionary to update.
-
-        Returns:
-            bool: True if the key was renamed, False if no migration was needed.
-        """
         tx_fees = will_settings.get("tx_fees", False)
         have_to_update = False
         if tx_fees:
@@ -1003,17 +486,6 @@ class Util:
         return have_to_update
 
     def fix_will_tx_fees(will):
-        """Migrate will transactions from old 'tx_fees' key to 'baltx_fees'.
-
-        Iterates through all will items and renames the 'tx_fees' key to
-        'baltx_fees' in each transaction for backward compatibility.
-
-        Args:
-            will (dict): Dictionary of will items keyed by transaction ID.
-
-        Returns:
-            bool: True if any key was renamed, False if no migration was needed.
-        """
         have_to_update = False
         for txid, willitem in will.items():
             tx_fees = willitem.get("tx_fees", False)
@@ -1022,30 +494,3 @@ class Util:
                 del will[txid]["tx_fees"]
                 have_to_update = True
         return have_to_update
-
-    def text_to_hex(text: str) -> str:
-        """Convert text to a hexadecimal string.
-
-        Args:
-            text (str): The text to convert.
-
-        Returns:
-            str: The hexadecimal representation of the text.
-        """
-        hex_string = text.encode('utf-8').hex()
-        return hex_string
-
-
-    def hex_to_text(hex_string: str) -> str:
-        """Convert a hexadecimal string back to text.
-
-        Args:
-            hex_string (str): The hexadecimal string to convert.
-
-        Returns:
-            str: The decoded text, or an error message if the hex string is invalid.
-        """
-        try:
-            return bytes.fromhex(hex_string).decode('utf-8')
-        except Exception:
-            return "Error: Invalid hex string"

will.py

@@ -1,11 +1,3 @@
-# -*- coding: utf-8 -*-
-
-# Will module for the BAL Electrum plugin.
-
-# -*- coding: utf-8 -*-
-
-# Will module for the BAL Electrum plugin.
-
 import copy
 
 from electrum.bitcoin import NLOCKTIME_BLOCKHEIGHT_MAX

willexecutors.py

@@ -1,13 +1,3 @@
-"""Willexecutors module for BAL Electrum Plugin.
-
-This module provides functionality to manage will executor servers that
-broadcast timelocked transactions at the appropriate locktime.
-
-Classes:
-    Willexecutors: Static class for managing executor list and communication
-    WillExecutor: Data class representing a single will executor
-"""
-
 import json
 from datetime import datetime
 import time
@@ -28,19 +18,8 @@ chainname = constants.net.NET_NAME if constants.net.NET_NAME != "mainnet" else "
 
 
 class Willexecutors:
-    """Static class managing will executor servers.
-
-    Provides methods to save/load configurations, communicate via HTTP,
-    push transactions, and download executor lists from remote sources.
-    """
 
     def save(bal_plugin, willexecutors):
-        """Save will executor configuration to plugin settings.
-
-        Args:
-            bal_plugin: BAL plugin instance
-            willexecutors: Dictionary of executor configs keyed by URL
-        """
         _logger.debug(f"save {willexecutors},{chainname}")
         aw = bal_plugin.WILLEXECUTORS.get()
         aw[chainname] = willexecutors
@@ -51,18 +30,6 @@ class Willexecutors:
     def get_willexecutors(
         bal_plugin, update=False, bal_window=False, force=False, task=True
     ):
-        """Retrieve and update the list of available will executors.
-
-        Args:
-            bal_plugin: BAL plugin instance
-            update: If True, ping servers to refresh data
-            bal_window: GUI window for user prompts
-            force: Force update regardless of cached data age
-            task: Run as background task if True
-
-        Returns:
-            dict: Sorted dictionary of executor configurations
-        """
         willexecutors = bal_plugin.WILLEXECUTORS.get()
         willexecutors = willexecutors.get(chainname, {})
         to_del = []
@@ -112,15 +79,6 @@ class Willexecutors:
         return w_sorted
 
     def is_selected(willexecutor, value=None):
-        """Check or set the selection status of an executor.
-
-        Args:
-            willexecutor: Executor configuration dictionary
-            value: Optional boolean to set selection status
-
-        Returns:
-            bool: Current selection status
-        """
         if not willexecutor:
             return False
         if value is not None:
@@ -132,15 +90,6 @@ class Willexecutors:
             return False
 
     def get_willexecutor_transactions(will, force=False):
-        """Collect transactions grouped by executor for valid, complete wills.
-
-        Args:
-            will: Dictionary of will items keyed by ID
-            force: Include already-pushed transactions
-
-        Returns:
-            dict: Executors with their aggregated transactions
-        """
         willexecutors = {}
         for wid, willitem in will.items():
             if willitem.get_status("VALID"):
@@ -178,22 +127,6 @@ class Willexecutors:
     def send_request(
         method, url, data=None, *, timeout=10, handle_response=None, count_reply=0
     ):
-        """Send HTTP request to a will executor server.
-
-        Args:
-            method: HTTP method (get/post)
-            url: Target server URL
-            data: Request payload
-            timeout: Timeout in seconds
-            handle_response: Response processing function
-            count_reply: Retry counter for timeouts
-
-        Returns:
-            Server response object
-
-        Raises:
-            Exception: On connection errors or invalid method
-        """
         network = Network.get_instance()
         if not network:
             raise Exception("You are offline.")
@@ -245,28 +178,12 @@ class Willexecutors:
             return response
 
     def get_we_url_from_response(resp):
-        """Extract base URL from response object.
-
-        Args:
-            resp: Response object with url attribute
-
-        Returns:
-            str: Base URL without trailing paths
-        """
         url_slices = str(resp.url).split("/")
         if len(url_slices) > 2:
             url_slices = url_slices[:-2]
         return "/".join(url_slices)
 
     async def handle_response(resp: ClientResponse):
-        """Parse JSON response from executor server.
-
-        Args:
-            resp: aiohttp ClientResponse object
-
-        Returns:
-            Parsed JSON data or raw text on parse failure
-        """
         r = await resp.text()
         try:
 
@@ -280,21 +197,9 @@ class Willexecutors:
         return r
 
     class AlreadyPresentException(Exception):
-        """Raised when transactions already exist on executor server."""
         pass
 
     def push_transactions_to_willexecutor(willexecutor):
-        """Push timelocked transactions to an executor server for broadcast.
-
-        Args:
-            willexecutor: Dict containing url and txs keys
-
-        Returns:
-            bool: True on success, False on failure
-
-        Raises:
-            AlreadyPresentException: If transactions already exist
-        """
         out = True
         try:
             _logger.debug(f"{willexecutor['url']}: {willexecutor['txs']}")
@@ -320,24 +225,10 @@ class Willexecutors:
         return out
 
     def ping_servers(willexecutors):
-        """Ping all executor servers to update their information.
-
-        Args:
-            willexecutors: Dictionary of executor configurations
-        """
         for url, we in willexecutors.items():
             Willexecutors.get_info_task(url, we)
 
     def get_info_task(url, willexecutor):
-        """Fetch current information from a single executor server.
-
-        Args:
-            url: Executor server URL
-            willexecutor: Configuration dict to update
-
-        Returns:
-            Updated willexecutor dict with status, base_fee, address
-        """
         w = None
         try:
             _logger.info("GETINFO_WILLEXECUTOR")
@@ -358,14 +249,6 @@ class Willexecutors:
         return willexecutor
 
     def initialize_willexecutor(willexecutor, url, status=None, old_willexecutor={}):
-        """Initialize or merge executor configuration preserving user settings.
-
-        Args:
-            willexecutor: New executor configuration dict
-            url: Executor server URL
-            status: Optional status override
-            old_willexecutor: Previous config to preserve user preferences
-        """
         willexecutor["url"] = url
         if status is not None:
             willexecutor["status"] = status
@@ -378,14 +261,6 @@ class Willexecutors:
 
 
     def download_list(old_willexecutors):
-        """Download latest executor list from remote source.
-
-        Args:
-            old_willexecutors: Existing configs to merge with new list
-
-        Returns:
-            dict: Merged executor configurations
-        """
         try:
             willexecutors = Willexecutors.send_request(
                 "get",
@@ -406,11 +281,6 @@ class Willexecutors:
             return {}
 
     def get_willexecutors_list_from_json():
-        """Load executor list from local willexecutors.json file.
-
-        Returns:
-            dict: Executor configurations from JSON file
-        """
         try:
             with open("willexecutors.json") as f:
                 willexecutors = json.load(f)
@@ -425,15 +295,6 @@ class Willexecutors:
             return {}
 
     def check_transaction(txid, url):
-        """Check if a transaction exists on executor server.
-
-        Args:
-            txid: Transaction ID string
-            url: Executor server URL
-
-        Returns:
-            Server response about transaction existence
-        """
         _logger.debug(f"{url}:{txid}")
         try:
             w = Willexecutors.send_request(
@@ -445,31 +306,10 @@ class Willexecutors:
             raise e
 
     def compute_id(willexecutor):
-        """Compute unique identifier for an executor.
-
-        Args:
-            willexecutor: Executor configuration dict
-
-        Returns:
-            str: Unique ID combining URL and chain name
-        """
         return "{}-{}".format(willexecutor.get("url"), willexecutor.get("chain"))
 
 
 class WillExecutor:
-    """Data class representing a single will executor server.
-
-    Attributes:
-        url: Executor server URL
-        base_fee: Fixed fee in satoshis
-        chain: Bitcoin chain name
-        info: Additional executor information
-        version: Plugin version compatibility
-        status: Connection status
-        is_selected: User selection flag
-        promo_code: Promotional discount code
-    """
-
     def __init__(
         self,
         url,
@@ -481,18 +321,6 @@ class WillExecutor:
         is_selected=False,
         promo_code="",
     ):
-        """Initialize a new WillExecutor instance.
-
-        Args:
-            url: Executor server URL
-            base_fee: Fixed fee in satoshis
-            chain: Bitcoin chain name
-            info: Additional executor information
-            version: Plugin version compatibility
-            status: Connection status (OK/Ko)
-            is_selected: Whether user has selected this executor
-            promo_code: Promotional discount code
-        """
         self.url = url
         self.base_fee = base_fee
         self.chain = chain
@@ -504,14 +332,6 @@ class WillExecutor:
         self.id = self.compute_id()
 
     def from_dict(d):
-        """Create WillExecutor instance from a dictionary.
-
-        Args:
-            d: Dictionary containing executor data fields
-
-        Returns:
-            WillExecutor: New instance with defaults for missing fields
-        """
         return WillExecutor(
             url=d.get("url", "http://localhost:8000"),
             base_fee=d.get("base_fee", 1000),
@@ -524,11 +344,6 @@ class WillExecutor:
         )
 
     def to_dict(self):
-        """Convert WillExecutor to dictionary representation.
-
-        Returns:
-            dict: Serializable representation excluding computed fields
-        """
         return {
             "url": self.url,
             "base_fee": self.base_fee,
@@ -539,9 +354,4 @@ class WillExecutor:
         }
 
     def compute_id(self):
-        """Generate unique identifier for this executor.
-
-        Returns:
-            str: Unique ID from URL and chain name
-        """
         return f"{self.url}-{self.chain}"