partial commit to fix wallet utils

this commit provide a lot of changes in will-settings including export to ics calendar file.

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

@@ -1,14 +1,14 @@
 import os
-
+from datetime import date, datetime, timedelta
+import platform
 # import random
 # import zipfile as zipfile_lib
-
+from electrum import constants, json_db
-from electrum import json_db
 from electrum.logging import get_logger
 from electrum.plugin import BasePlugin
 from electrum.transaction import tx_from_any
 
-
+_logger = get_logger(__name__)
 def get_will_settings(x):
     # print(x)
     pass
@@ -49,6 +49,12 @@ class BalConfig:
 class BalPlugin(BasePlugin):
     _version=None
     __version__ = "0.2.8" #AUTOMATICALLY GENERATED DO NOT EDIT
+    default_app={
+            "Linux":"xdg-open",
+            "Window":"start",
+            "Darwin":"open"
+    }
+    chainname = constants.net.NET_NAME if constants.net.NET_NAME != "mainnet" else "bitcoin"
     def version(self):
         if not self._version:
             try:
@@ -59,7 +65,7 @@ class BalPlugin(BasePlugin):
             except Exception as e:
                 _logger.error(f"failed to get version: {e}")
                 self._version="unknown"
-        return self._version        
+        return self._version
 
     SIZE = (159, 97)
 
@@ -100,6 +106,7 @@ class BalPlugin(BasePlugin):
         self.HIDE_INVALIDATED = BalConfig(config, "bal_hide_invalidated", True)
         self.ALLOW_REPUSH = BalConfig(config, "bal_allow_repush", True)
         self.FIRST_EXECUTION = BalConfig(config, "bal_first_execution", True)
+        self.WELIST_SERVER = BalConfig(config,"bal_welist_server","https://welist.bitcoin-after.life/")
         self.WILLEXECUTORS = BalConfig(
             config,
             "bal_willexecutors",
@@ -122,18 +129,33 @@ class BalPlugin(BasePlugin):
                         "selected": True,
                     }
                 },
+                "testnet4": {
+                    "https://we.bitcoin-after.life": {
+                        "base_fee": 100000,
+                        "status": "New",
+                        "info": "Bitcoin After Life Will Executor",
+                        "address": "bcrt1qa5cntu4hgadw8zd3n6sq2nzjy34sxdtd9u0gp7",
+                        "selected": True,
+                    }
+                },
+                "regtest": {
+                    "https://we.bitcoin-after.life": {
+                        "base_fee": 100000,
+                        "status": "New",
+                        "info": "Bitcoin After Life Will Executor",
+                        "address": "bcrt1qa5cntu4hgadw8zd3n6sq2nzjy34sxdtd9u0gp7",
+                        "selected": True,
+                    }
+                },
             },
         )
         self.WILL_SETTINGS = BalConfig(
             config,
             "bal_will_settings",
-            {
+            BalPlugin.default_will_settings(),
-                "baltx_fees": 100,
-                "threshold": "180d",
-                "locktime": "1y",
-            },
         )
-
+        self.system = platform.system()
+        self.CALENDAR_APP = BalConfig(config,"bal_open_app",self.default_app[self.system])
         self._hide_invalidated = self.HIDE_INVALIDATED.get()
         self._hide_replaced = self.HIDE_REPLACED.get()
 
@@ -149,13 +171,22 @@ class BalPlugin(BasePlugin):
         self.HIDE_REPLACED.set(self._hide_replaced)
 
     def validate_will_settings(self, will_settings):
-        if int(will_settings.get("baltx_fees", 1)) < 1:
+        defaults=BalPlugin.default_will_settings()
-            will_settings["baltx_fees"] = 1
+        if not will_settings:
+            will_settings=[]
+        if int(will_settings.get("baltx_fees", 0)) < 1:
+            will_settings["baltx_fees"] = defaults['baltx_fees']
         if not will_settings.get("threshold"):
-            will_settings["threshold"] = "180d"
+            will_settings["threshold"] = defaults['threshold']
         if not will_settings.get("locktime"):
-            will_settings["locktime"] = "1y"
+            will_settings["locktime"] = defaults['locktime']
         return will_settings
 
-    def default_will_settings(self):
+    @staticmethod
-        return {"baltx_fees": 100, "threshold": "180d", "locktime": "1y"}
+    def default_will_settings():
+        today = date.today()
+        dt = datetime(today.year, today.month, today.day, 0, 0, 0)
+        threshold =(dt + timedelta(days=180)).timestamp()
+        locktime =(dt + timedelta(days=365)).timestamp()
+
+        return {"baltx_fees": 100, "threshold": threshold, "locktime": locktime}

heirs.py

@@ -30,12 +30,11 @@ from electrum.transaction import (
     PartialTransaction,
     PartialTxInput,
     PartialTxOutput,
-    TxOutput,
     TxOutpoint,
     # TxOutput,
 )
-from electrum.payment_identifier import PaymentIdentifier
 from electrum.util import (
+    BitcoinException,
     bfh,
     read_json_file,
     to_string,
@@ -45,7 +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
 
@@ -75,10 +74,10 @@ def reduce_outputs(in_amount, out_amount, fee, outputs):
 def create_op_return_script(data_hex: str) -> bytes:
     """Crea scriptpubkey OP_RETURN in bytes"""
     data = bytes.fromhex(data_hex)
-    
+
     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
@@ -86,7 +85,7 @@ def create_op_return_script(data_hex: str) -> bytes:
     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):
@@ -164,7 +163,7 @@ def prepare_transactions(locktimes, available_utxos, fees, wallet):
             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)
@@ -184,7 +183,7 @@ def prepare_transactions(locktimes, available_utxos, fees, wallet):
         tx.remove_signatures()
         txid = tx.txid()
         if txid is None:
-            raise Exception("txid is none", tx)
+            raise Exception(f"txid is none: {tx}")
 
         tx.heirs = paid_heirs
         tx.my_locktime = locktime

util.py

@@ -1,39 +1,14 @@
-# -*- coding: utf-8 -*-
-
-# Utility module for the BAL Electrum plugin.
-
 import bisect
 from datetime import datetime, timedelta
 
-from electrum.gui.qt.util import getSaveFileName
-from electrum.i18n import _
 from electrum.transaction import PartialTxOutput
-from electrum.util import FileExportFailed
 
 LOCKTIME_THRESHOLD = 500000000
 
 
 class Util:
-    """Utility class providing static methods for the BAL Electrum Plugin.
+    @staticmethod
-
-    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:
@@ -44,21 +19,8 @@ class Util:
             pass
         return str(locktime)
 
+    @staticmethod
     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
@@ -70,24 +32,8 @@ class Util:
         timestamp = dt_object.timestamp()
         return int(timestamp)
 
+    @staticmethod
     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)
 
@@ -114,22 +60,8 @@ class Util:
             pass
         return 0
 
+    @staticmethod
     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
@@ -138,21 +70,8 @@ class Util:
             + blocks * 600
         )
 
+    @staticmethod
     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:
@@ -161,21 +80,8 @@ class Util:
             except Exception:
                 return 0
 
+    @staticmethod
     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:
@@ -185,31 +91,15 @@ class Util:
             except Exception:
                 return str(amount)
 
+    @staticmethod
     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
 
+    @staticmethod
     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
@@ -220,33 +110,14 @@ class Util:
         except Exception:
             return False
 
+    @staticmethod
     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
 
+    @staticmethod
     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:
@@ -260,20 +131,8 @@ class Util:
             return False
         return False
 
+    @staticmethod
     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:
@@ -284,43 +143,17 @@ class Util:
                 return h
         return False
 
+    @staticmethod
     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
         return True
 
+    @staticmethod
     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
@@ -342,32 +175,13 @@ class Util:
         else:
             return True
 
+    @staticmethod
     def cmp_heirs(
         heirsa,
         heirsb,
         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:
@@ -384,17 +198,8 @@ class Util:
             raise e
             return False
 
+    @staticmethod
     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:
@@ -402,22 +207,8 @@ class Util:
                 return False
         return True
 
+    @staticmethod
     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:
@@ -426,37 +217,16 @@ class Util:
                     return False
         return True
 
+    @staticmethod
     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()):
             return False
         return True
 
+    @staticmethod
     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
@@ -474,25 +244,8 @@ class Util:
 
         return value_amount
 
+    @staticmethod
     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:
@@ -502,26 +255,8 @@ class Util:
         else:
             return False
 
+    @staticmethod
     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:
@@ -537,19 +272,8 @@ class Util:
             out = 1
         return out
 
+    @staticmethod
     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)
@@ -562,49 +286,21 @@ class Util:
             else:
                 return int(locktimea) - (locktimeb)
 
+    @staticmethod
     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
 
+    @staticmethod
     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()
 
+    @staticmethod
     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:
@@ -616,76 +312,31 @@ class Util:
 
         return sorted(sorted_timestamp), sorted(sorted_block)
 
+    @staticmethod
     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))
 
+    @staticmethod
     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
 
+    @staticmethod
     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")
 
+    @staticmethod
     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()
 
         return utxos
 
+    @staticmethod
     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:
@@ -696,16 +347,8 @@ class Util:
             pass
         return str(utxo)
 
+    @staticmethod
     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:
@@ -713,58 +356,26 @@ class Util:
         else:
             return False
 
+    @staticmethod
     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
 
+    @staticmethod
     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
 
+    @staticmethod
     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
 
+    @staticmethod
     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
@@ -775,23 +386,8 @@ class Util:
     # return true false same amount different address
     # return false false different amount, different address not found
 
+    @staticmethod
     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):
@@ -806,23 +402,8 @@ class Util:
         else:
             return False, False
 
+    @staticmethod
     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()
@@ -832,19 +413,8 @@ class Util:
             out.is_change = True
             return out
 
+    @staticmethod
     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
@@ -865,17 +435,8 @@ class Util:
         height = min(chain_height, server_height)
         return height
 
+    @staticmethod
     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:
@@ -909,16 +470,8 @@ class Util:
 
         print(f"---end {name}---")
 
+    @staticmethod
     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)
@@ -929,71 +482,21 @@ class Util:
         print("_TxInput__value_sats:", utxo._TxInput__value_sats)
         print(f"---utxo-end {name}---")
 
+    @staticmethod
     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,
-            title=_("Select file to save your {}".format(title)),
-            filename="BALplugin_{}".format(title),
-            filter=filter_,
-            config=electrum_window.config,
-        )
-        if not filename:
-            return
-        try:
-            exporter(filename)
-        except FileExportFailed as e:
-            electrum_window.show_critical(str(e))
-        else:
-            electrum_window.show_message(
-                _("Your {0} were exported to '{1}'".format(title, str(filename)))
-            )
 
+    @staticmethod
     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
 
+    @staticmethod
     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:
@@ -1002,18 +505,8 @@ class Util:
             have_to_update = True
         return have_to_update
 
+    @staticmethod
     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)
@@ -1023,29 +516,18 @@ class Util:
                 have_to_update = True
         return have_to_update
 
+    @staticmethod
     def text_to_hex(text: str) -> str:
-        """Convert text to a hexadecimal string.
+        """Convert text to 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
 
 
+    @staticmethod
     def hex_to_text(hex_string: str) -> str:
-        """Convert a hexadecimal string back to text.
+        """Convert hexadecimal string back to text (for verification)"""
-
-        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"
+

wallet_util/README.md

@@ -0,0 +1,50 @@
+## README
+
+### Overview
+This tool provides two entry points: a CLI script (bal_wallet_utils.py) and a Qt GUI script (bal_wallet_utils_qt.py) that operate against an Electrum source tree.
+
+### Installation / Preparation
+1. Copy both files into the Electrum project root (the folder that contains the Electrum source package):
+   - bal_wallet_utils.py
+   - bal_wallet_utils_qt.py
+
+2. Activate the Electrum Python environment (the virtualenv used to run Electrum). Example (PowerShell, adjust path to your venv):
+```
+.\env\Scripts\Activate.ps1
+```
+or (cmd):
+```
+env\Scripts\activate.bat
+```
+
+### Running
+- CLI version:
+```
+python bal_wallet_utils.py
+```
+- Qt GUI version:
+```
+python bal_wallet_utils_qt.py
+```
+
+### Building a Windows executable with PyInstaller
+From the project root (with the Electrum environment active), you can build the Qt executable using PyInstaller. Example command (adjust the paths if your environment path differs):
+```
+pyinstaller.exe --onefile --noconsole --add-data "electrum\currencies.json;electrum" --add-data "electrum\bip39_wallet_formats.json;electrum" --add-data "electrum\lnwire\peer_wire.csv;electrum\lnwire" --add-data "electrum\lnwire\onion_wire.csv;electrum\lnwire" --add-binary "env/Lib/site-packages\electrum_ecc\libsecp256k1-6.dll;electrum_ecc" bal_wallet_utils_qt.py
+```
+
+Notes:
+- Run the command from the project root so relative paths resolve correctly.
+- On Windows the --add-data and --add-binary arguments use ";" to separate source and destination.
+- If electrum expects additional data files or native DLLs, include them with additional --add-data / --add-binary flags.
+- For debugging include --onedir first to inspect the created folder before using --onefile.
+
+### Troubleshooting
+- If PyInstaller is not found, run it via Python:
+```
+python -m PyInstaller <same arguments>
+```
+- If the frozen exe fails because DLLs or JSON files are missing, add those files explicitly with --add-data or --add-binary.
+- Test the build on a clean Windows VM to ensure all runtime dependencies are included.
+
+License and attribution: include your preferred license or attribution details here.

wallet_util/bal_wallet_utils.py

@@ -1,10 +1,11 @@
 #!env/bin/python3
-from electrum.storage import WalletStorage
-import json
-from electrum.util import MyEncoder
-import sys
 import getpass
+import json
 import os
+import sys
+
+from electrum.storage import WalletStorage
+from electrum.util import MyEncoder
 
 default_fees = 100
 
@@ -26,9 +27,12 @@ def fix_will_settings_tx_fees(json_wallet):
 
 
 def uninstall_bal(json_wallet):
-    del json_wallet["will_settings"]
+    if "will_settings" in json_wallet:
-    del json_wallet["will"]
+        del json_wallet["will_settings"]
-    del json_wallet["heirs"]
+    if "will" in json_wallet:
+        del json_wallet["will"]
+    if "heirs" in json_wallet:
+        del json_wallet["heirs"]
     return True
 
 

wallet_util/bal_wallet_utils_qt.py

@@ -1,30 +1,31 @@
 #!/usr/bin/env python3
-import sys
-import os
 import json
+import os
+import sys
+
+from bal_wallet_utils import fix_will_settings_tx_fees, save, uninstall_bal
+from electrum.storage import WalletStorage
 from PyQt6.QtWidgets import (
     QApplication,
-    QMainWindow,
+    QFileDialog,
-    QVBoxLayout,
+    QGroupBox,
     QHBoxLayout,
     QLabel,
     QLineEdit,
+    QMainWindow,
     QPushButton,
-    QWidget,
-    QFileDialog,
-    QGroupBox,
     QTextEdit,
+    QVBoxLayout,
+    QWidget,
 )
-from electrum.storage import WalletStorage
-from bal_wallet_utils import fix_will_settings_tx_fees, uninstall_bal, save
 
 
 class WalletUtilityGUI(QMainWindow):
     def __init__(self):
         super().__init__()
-        self.initUI()
+        self.init_ui()
 
-    def initUI(self):
+    def init_ui(self):
         self.setWindowTitle("BAL Wallet Utility")
         self.setFixedSize(500, 400)
 

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
@@ -32,6 +24,7 @@ _logger = get_logger(__name__)
 
 
 class Will:
+    @staticmethod
     def get_children(will, willid):
         out = []
         for _id in will:
@@ -43,6 +36,7 @@ class Will:
         return out
 
     # build a tree with parent transactions
+    @staticmethod
     def add_willtree(will):
         for willid in will:
             will[willid].children = Will.get_children(will, willid)
@@ -51,14 +45,17 @@ class Will:
                     will[child[0]].father = willid
 
     # return a list of will sorted by locktime
+    @staticmethod
     def get_sorted_will(will):
         return sorted(will.items(), key=lambda x: x[1]["tx"].locktime)
 
+    @staticmethod
     def only_valid(will):
         for k, v in will.items():
             if v.get_status("VALID"):
                 yield k
 
+    @staticmethod
     def search_equal_tx(will, tx, wid):
         for w in will:
             if w != wid and not tx.to_json() != will[w]["tx"].to_json():
@@ -67,6 +64,7 @@ class Will:
                         return will[w]["tx"]
         return False
 
+    @staticmethod
     def get_tx_from_any(x):
         try:
             a = str(x)
@@ -77,6 +75,7 @@ class Will:
 
         return x
 
+    @staticmethod
     def add_info_from_will(will, wid, wallet):
         if isinstance(will[wid].tx, str):
             will[wid].tx = Will.get_tx_from_any(will[wid].tx)
@@ -97,7 +96,9 @@ class Will:
                 txin._TxInput__value_sats = change.value
                 txin._trusted_value_sats = change.value
 
-    def normalize_will(will, wallet=None, others_inputs={}):
+    @staticmethod
+    def normalize_will(will, wallet=None, others_inputs=None):
+        others_input = others_inputs if others_inputs is not None else {}
         to_delete = []
         to_add = {}
         # add info from wallet
@@ -146,6 +147,7 @@ class Will:
             if wid in will:
                 del will[wid]
 
+    @staticmethod
     def new_input(txid, idx, change):
         prevout = TxOutpoint(txid=bfh(txid), out_idx=idx)
         inp = PartialTxInput(prevout=prevout)
@@ -156,16 +158,7 @@ class Will:
         inp._TxInput__value_sats = change.value
         return inp
 
-    """
+    @staticmethod
-    in questa situazione sono presenti due transazioni con id differente(quindi transazioni differenti)
-    per prima cosa controllo il locktime
-    se il locktime della nuova transazione e' maggiore del locktime della vecchia transazione, allora
-    confronto gli eredi, per locktime se corrispondono controllo i willexecutor
-    se hanno la stessa url ma le fee vecchie sono superiori alle fee nuove, allora anticipare. 
-
-
-    """
-
     def check_anticipate(ow: "WillItem", nw: "WillItem"):
         anticipate = Util.anticipate_locktime(ow.tx.locktime, days=1)
         if int(nw.tx.locktime) >= int(anticipate):
@@ -195,6 +188,7 @@ class Will:
                 return anticipate
         return 4294967295 + 1
 
+    @staticmethod
     def change_input(will, otxid, idx, change, others_inputs, to_delete, to_append):
         ow = will[otxid]
         ntxid = ow.tx.txid()
@@ -235,6 +229,7 @@ class Will:
                             to_append,
                         )
 
+    @staticmethod
     def get_all_inputs(will, only_valid=False):
         all_inputs = {}
         for w, wi in will.items():
@@ -249,6 +244,7 @@ class Will:
                         all_inputs[prevout_str].append(inp)
         return all_inputs
 
+    @staticmethod
     def get_all_inputs_min_locktime(all_inputs):
         all_inputs_min_locktime = {}
 
@@ -263,6 +259,7 @@ class Will:
 
         return all_inputs_min_locktime
 
+    @staticmethod
     def search_anticipate_rec(will, old_inputs):
         redo = False
         to_delete = []
@@ -302,6 +299,7 @@ class Will:
 
             Will.search_anticipate_rec(will, old_inputs)
 
+    @staticmethod
     def update_will(old_will, new_will):
         all_old_inputs = Will.get_all_inputs(old_will, only_valid=True)
         # all_inputs_min_locktime = Will.get_all_inputs_min_locktime(all_old_inputs)
@@ -328,6 +326,7 @@ class Will:
             else:
                 continue
 
+    @staticmethod
     def get_higher_input_for_tx(will):
         out = {}
         for wid in will:
@@ -341,6 +340,7 @@ class Will:
                 out[inp.prevout.to_str()] = inp
         return out
 
+    @staticmethod
     def invalidate_will(will, wallet, fees_per_byte):
         will_only_valid = Will.only_valid_list(will)
         inputs = Will.get_all_inputs(will_only_valid)
@@ -392,11 +392,13 @@ class Will:
             _logger.debug("len utxo_to_spend <=0")
             pass
 
+    @staticmethod
     def is_new(will):
         for wid, w in will.items():
             if w.get_status("VALID") and not w.get_status("COMPLETE"):
                 return True
 
+    @staticmethod
     def search_rai(all_inputs, all_utxos, will, wallet):
         # will_only_valid = Will.only_valid_or_replaced_list(will)
         for inp, ws in all_inputs.items():
@@ -430,20 +432,25 @@ class Will:
                 else:
                     pass
 
+    @staticmethod
     def utxos_strs(utxos):
         return [Util.utxo_to_str(u) for u in utxos]
 
-    def set_invalidate(wid, will=[]):
+    @staticmethod
+    def set_invalidate(wid, will=None):
+        will = will if will is not None else {}
         will[wid].set_status("INVALIDATED", True)
         if will[wid].children:
             for c in will[wid].children.items():
                 Will.set_invalidate(c[0], will)
 
+    @staticmethod
     def check_tx_height(tx, wallet):
         info = wallet.get_tx_info(tx)
         return info.tx_mined_status.height()
 
     # check if transactions are stil valid tecnically valid
+    @staticmethod
     def check_invalidated(willtree, utxos_list, wallet):
         for wid, w in willtree.items():
             if (
@@ -476,6 +483,7 @@ class Will:
     #                    if wc.children:
     #                        Will.reflect_to_children(wc)
 
+    @staticmethod
     def check_amounts(heirs, willexecutors, all_utxos, timestamp_to_check, dust):
         fixed_heirs, fixed_amount, perc_heirs, perc_amount, fixed_amount_with_dust = (
             heirs.fixed_percent_lists_amount(timestamp_to_check, dust, reverse=True)
@@ -499,6 +507,7 @@ class Will:
                         f"Willexecutor{url} excess base fee({wex['base_fee']}), {fixed_amount} >={temp_balance}"
                     )
 
+    @staticmethod
     def check_will(will, all_utxos, wallet, block_to_check, timestamp_to_check):
         Will.add_willtree(will)
         utxos_list = Will.utxos_strs(all_utxos)
@@ -515,18 +524,28 @@ class Will:
 
         Will.search_rai(all_inputs, all_utxos, will, wallet)
 
+    @staticmethod
+    def get_min_locktime(will,default_value=None):
+        return min((v.tx.locktime for v in will.values() if v.get_status('VALID')), default=default_value)            
+
+
+
+    @staticmethod
     def is_will_valid(
         will,
         block_to_check,
         timestamp_to_check,
         tx_fees,
         all_utxos,
-        heirs={},
+        heirs=None,
-        willexecutors={},
+        willexecutors=None,
         self_willexecutor=False,
         wallet=False,
         callback_not_valid_tx=None,
     ):
+        heirs = heirs if heirs is not None else {}
+        willexecutors= willexecutors if willexecutors is not None else {}
+
         Will.check_will(will, all_utxos, wallet, block_to_check, timestamp_to_check)
         if heirs:
             if not Will.check_willexecutors_and_heirs(
@@ -555,6 +574,7 @@ class Will:
         _logger.info("will ok")
         return True
 
+    @staticmethod
     def check_will_expired(all_inputs_min_locktime, block_to_check, timestamp_to_check):
         _logger.info("check if some transaction is expired")
         for prevout_str, wid in all_inputs_min_locktime.items():
@@ -586,6 +606,7 @@ class Will:
     #                    if not parentwill or not parentwill.get_status("VALID"):
     #                        w[1].set_status("INVALIDATED", True)
 
+    @staticmethod
     def only_valid_list(will):
         out = {}
         for wid, w in will.items():
@@ -593,6 +614,7 @@ class Will:
                 out[wid] = w
         return out
 
+    @staticmethod
     def only_valid_or_replaced_list(will):
         out = []
         for wid, w in will.items():
@@ -601,6 +623,7 @@ class Will:
                 out.append(wid)
         return out
 
+    @staticmethod
     def check_willexecutors_and_heirs(
         will, heirs, willexecutors, self_willexecutor, check_date, tx_fees
     ):
@@ -614,7 +637,7 @@ class Will:
         for wid in Will.only_valid_list(will):
             w = will[wid]
             if w.tx_fees != tx_fees:
-                raise TxFeesChangedException(f"{tx_fees}:", w.tx_fees)
+                raise TxFeesChangedException(f"{tx_fees}:  {w.tx_fees}")
             for wheir in w.heirs:
                 if not 'w!ll3x3c"' == wheir[:9]:
                     their = will[wid].heirs[wheir]
@@ -663,6 +686,7 @@ class Will:
         return True
 
 
+
 class WillItem(Logger):
     STATUS_DEFAULT = {
         "ANTICIPATED": ["Anticipated", False],

willexecutors.py

@@ -1,19 +1,8 @@
-"""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
+from datetime import datetime
 
 from aiohttp import ClientResponse
-from electrum import constants
 from electrum.i18n import _
 from electrum.logging import get_logger
 from electrum.network import Network
@@ -24,23 +13,13 @@ DEFAULT_TIMEOUT = 5
 _logger = get_logger(__name__)
 
 
-chainname = constants.net.NET_NAME if constants.net.NET_NAME != "mainnet" else "bitcoin"
+chainname = BalPlugin.chainname
 
 
 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.
-    """
 
+    @staticmethod
     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
@@ -48,21 +27,10 @@ class Willexecutors:
         _logger.debug(f"saved: {aw}")
         # bal_plugin.WILLEXECUTORS.set(willexecutors)
 
+    @staticmethod
     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 = []
@@ -111,16 +79,8 @@ class Willexecutors:
         )
         return w_sorted
 
+    @staticmethod
     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:
@@ -131,16 +91,8 @@ class Willexecutors:
             willexecutor["selected"] = False
             return False
 
+    @staticmethod
     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"):
@@ -175,25 +127,10 @@ class Willexecutors:
     #                    willexecutors[url]["txs"], url
     #                )
 
+    @staticmethod
     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.")
@@ -244,29 +181,15 @@ class Willexecutors:
             _logger.debug(f"--> {response}")
             return response
 
+    @staticmethod
     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)
 
+    @staticmethod
     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:
 
@@ -279,22 +202,12 @@ class Willexecutors:
             pass
         return r
 
+    @staticmethod
     class AlreadyPresentException(Exception):
-        """Raised when transactions already exist on executor server."""
         pass
 
+    @staticmethod
     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']}")
@@ -319,25 +232,13 @@ class Willexecutors:
 
         return out
 
+    @staticmethod
     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)
 
+    @staticmethod
     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")
@@ -357,15 +258,9 @@ class Willexecutors:
         willexecutor["last_update"] = datetime.now().timestamp()
         return willexecutor
 
-    def initialize_willexecutor(willexecutor, url, status=None, old_willexecutor={}):
+    @staticmethod
-        """Initialize or merge executor configuration preserving user settings.
+    def initialize_willexecutor(willexecutor, url, status=None, old_willexecutor=None):
-
+        old_willexecutor=old_willexecutor if old_willexecutor is not None else {}
-        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
@@ -377,19 +272,13 @@ class Willexecutors:
 
 
 
-    def download_list(old_willexecutors):
+    @staticmethod
-        """Download latest executor list from remote source.
+    def download_list(old_willexecutors,welist_server):
-
-        Args:
-            old_willexecutors: Existing configs to merge with new list
-
-        Returns:
-            dict: Merged executor configurations
-        """
         try:
+            welist_server = welist_server if welist_server[-1] == '/' else welist_server+'/'
             willexecutors = Willexecutors.send_request(
                 "get",
-                f"https://welist.bitcoin-after.life/data/{chainname}?page=0&limit=100",
+                f"{welist_server}data/{chainname}?page=0&limit=100",
             )
             # del willexecutors["status"]
             for w in willexecutors:
@@ -405,12 +294,8 @@ class Willexecutors:
             _logger.error(f"Failed to download willexecutors list: {e}")
             return {}
 
+    @staticmethod
     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)
@@ -424,16 +309,8 @@ class Willexecutors:
 
             return {}
 
+    @staticmethod
     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(
@@ -444,104 +321,54 @@ class Willexecutors:
             _logger.error(f"error contacting {url} for checking txs {e}")
             raise e
 
+    @staticmethod
     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:
+#class WillExecutor:
-    """Data class representing a single will executor server.
+#    def __init__(
-
+#        self,
-    Attributes:
+#        url,
-        url: Executor server URL
+#        base_fee,
-        base_fee: Fixed fee in satoshis
+#        chain,
-        chain: Bitcoin chain name
+#        info,
-        info: Additional executor information
+#        version,
-        version: Plugin version compatibility
+#        status,
-        status: Connection status
+#        is_selected=False,
-        is_selected: User selection flag
+#        promo_code="",
-        promo_code: Promotional discount code
+#    ):
-    """
+#        self.url = url
-
+#        self.base_fee = base_fee
-    def __init__(
+#        self.chain = chain
-        self,
+#        self.info = info
-        url,
+#        self.version = version
-        base_fee,
+#        self.status = status
-        chain,
+#        self.promo_code = promo_code
-        info,
+#        self.is_selected = is_selected
-        version,
+#        self.id = self.compute_id()
-        status,
+#
-        is_selected=False,
+#    def from_dict(d):
-        promo_code="",
+#        return WillExecutor(
-    ):
+#            url=d.get("url", "http://localhost:8000"),
-        """Initialize a new WillExecutor instance.
+#            base_fee=d.get("base_fee", 1000),
-
+#            chain=d.get("chain", chainname),
-        Args:
+#            info=d.get("info", ""),
-            url: Executor server URL
+#            version=d.get("version", 0),
-            base_fee: Fixed fee in satoshis
+#            status=d.get("status", "Ko"),
-            chain: Bitcoin chain name
+#            is_selected=d.get("is_selected", "False"),
-            info: Additional executor information
+#            promo_code=d.get("promo_code", ""),
-            version: Plugin version compatibility
+#        )
-            status: Connection status (OK/Ko)
+#
-            is_selected: Whether user has selected this executor
+#    def to_dict(self):
-            promo_code: Promotional discount code
+#        return {
-        """
+#            "url": self.url,
-        self.url = url
+#            "base_fee": self.base_fee,
-        self.base_fee = base_fee
+#            "chain": self.chain,
-        self.chain = chain
+#            "info": self.info,
-        self.info = info
+#            "version": self.version,
-        self.version = version
+#            "promo_code": self.promo_code,
-        self.status = status
+#        }
-        self.promo_code = promo_code
+#
-        self.is_selected = is_selected
+#    def compute_id(self):
-        self.id = self.compute_id()
+#        return f"{self.url}-{self.chain}"
-
-    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),
-            chain=d.get("chain", chainname),
-            info=d.get("info", ""),
-            version=d.get("version", 0),
-            status=d.get("status", "Ko"),
-            is_selected=d.get("is_selected", "False"),
-            promo_code=d.get("promo_code", ""),
-        )
-
-    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,
-            "chain": self.chain,
-            "info": self.info,
-            "version": self.version,
-            "promo_code": self.promo_code,
-        }
-
-    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}"