docs(will): add module header

# Conflicts:
#	qt.py

README.md

@@ -1,2 +1,357 @@
-# BalPlugin
-Bitcoin After Life Electrum Plugin
+# Bal 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.

VERSION

@@ -1 +1 @@
-0.2.3
+0.2.8

bal.py

@@ -1,6 +1,7 @@
 import os
-#import random
-#import zipfile as zipfile_lib
+
+# import random
+# import zipfile as zipfile_lib
 
 from electrum import json_db
 from electrum.logging import get_logger
@@ -9,7 +10,7 @@ from electrum.transaction import tx_from_any
 
 
 def get_will_settings(x):
-    #print(x)
+    # print(x)
     pass
 
 
@@ -18,7 +19,6 @@ json_db.register_dict("will", dict, None)
 json_db.register_dict("will_settings", lambda x: x, None)
 
 
-
 def get_will(x):
     try:
         x["tx"] = tx_from_any(x["tx"])
@@ -47,18 +47,19 @@ class BalConfig:
 
 
 class BalPlugin(BasePlugin):
-    LATEST_VERSION = "1"
-    KNOWN_VERSIONS = ("0", "1")
-    assert LATEST_VERSION in KNOWN_VERSIONS
-
-    def version():
-        try:
-            f = ""
-            with open("VERSION", "r") as fi:
-                f = str(fi.readline())
-            return f
-        except:
-            return "unknown"
+    _version=None
+    __version__ = "0.2.8" #AUTOMATICALLY GENERATED DO NOT EDIT
+    def version(self):
+        if not self._version:
+            try:
+                f = ""
+                with open("{}/VERSION".format(self.plugin_dir), "r") as fi:
+                    f = str(fi.read())
+                self._version = f.strip()
+            except Exception as e:
+                _logger.error(f"failed to get version: {e}")
+                self._version="unknown"
+        return self._version        
 
     SIZE = (159, 97)
 
@@ -68,15 +69,9 @@ class BalPlugin(BasePlugin):
         self.base_dir = os.path.join(config.electrum_path(), "bal")
         self.plugin_dir = os.path.split(os.path.realpath(__file__))[0]
         zipfile = "/".join(self.plugin_dir.split("/")[:-1])
-        # print("real path",os.path.realpath(__file__))
-        # self.logger.info(self.base_dir)
-        # print("base_dir:", self.base_dir)
-        # print("suca:",zipfile)
-        # print("plugin_dir:", self.plugin_dir)
         import sys
 
         sys.path.insert(0, zipfile)
-        # print("sono state listate?")
         self.parent = parent
         self.config = config
         self.name = name
@@ -96,10 +91,10 @@ class BalPlugin(BasePlugin):
         self.PREVIEW = BalConfig(config, "bal_preview", True)
         self.SAVE_TXS = BalConfig(config, "bal_save_txs", True)
         self.WILLEXECUTORS = BalConfig(config, "bal_willexecutors", True)
-        self.PING_WILLEXECUTORS = BalConfig(config, "bal_ping_willexecutors", True)
-        self.ASK_PING_WILLEXECUTORS = BalConfig(
-            config, "bal_ask_ping_willexecutors", True
-        )
+        # self.PING_WILLEXECUTORS = BalConfig(config, "bal_ping_willexecutors", True)
+        # self.ASK_PING_WILLEXECUTORS = BalConfig(
+        #    config, "bal_ask_ping_willexecutors", True
+        # )
         self.NO_WILLEXECUTOR = BalConfig(config, "bal_no_willexecutor", True)
         self.HIDE_REPLACED = BalConfig(config, "bal_hide_replaced", True)
         self.HIDE_INVALIDATED = BalConfig(config, "bal_hide_invalidated", True)
@@ -110,6 +105,15 @@ class BalPlugin(BasePlugin):
             "bal_willexecutors",
             {
                 "mainnet": {
+                    "https://we.bitcoin-after.life": {
+                        "base_fee": 100000,
+                        "status": "New",
+                        "info": "Bitcoin After Life Will Executor",
+                        "address": "bc1qusymuetsz2psaqzqxv8qmzcy64d9meckj3lxxf",
+                        "selected": True,
+                    }
+                },
+                "testnet": {
                     "https://we.bitcoin-after.life": {
                         "base_fee": 100000,
                         "status": "New",
@@ -117,7 +121,7 @@ class BalPlugin(BasePlugin):
                         "address": "bcrt1qa5cntu4hgadw8zd3n6sq2nzjy34sxdtd9u0gp7",
                         "selected": True,
                     }
-                }
+                },
             },
         )
         self.WILL_SETTINGS = BalConfig(
@@ -145,16 +149,13 @@ class BalPlugin(BasePlugin):
         self.HIDE_REPLACED.set(self._hide_replaced)
 
     def validate_will_settings(self, will_settings):
-        # print(type(will_settings))
-        # print(will_settings.get('baltx_fees',1),1)
         if int(will_settings.get("baltx_fees", 1)) < 1:
             will_settings["baltx_fees"] = 1
         if not will_settings.get("threshold"):
             will_settings["threshold"] = "180d"
-        if not will_settings.get("locktime") == "":
+        if not will_settings.get("locktime"):
             will_settings["locktime"] = "1y"
         return will_settings
 
     def default_will_settings(self):
         return {"baltx_fees": 100, "threshold": "180d", "locktime": "1y"}
-

heirs.py

@@ -1,24 +1,40 @@
-import datetime
-import json
+# import datetime
+# import json
 import math
 import random
 import re
 import threading
-import urllib.parse
-import urllib.request
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Tuple
+
+# import urllib.parse
+# import urllib.request
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    # List,
+    Optional,
+    # Sequence,
+    Tuple,
+)
 
 import dns
 from dns.exception import DNSException
-from electrum import bitcoin, constants, descriptor, dnssec
+from electrum import (
+    bitcoin,
+    constants,
+    # descriptor,
+    dnssec,
+)
 from electrum.logging import Logger, get_logger
 from electrum.transaction import (
     PartialTransaction,
     PartialTxInput,
     PartialTxOutput,
-    TxOutpoint,
     TxOutput,
+    TxOutpoint,
+    # TxOutput,
 )
+from electrum.payment_identifier import PaymentIdentifier
 from electrum.util import (
     bfh,
     read_json_file,
@@ -29,10 +45,11 @@ 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
-    from .wallet_db import WalletDB
+
+    # from .wallet_db import WalletDB
 
 
 _logger = get_logger(__name__)
@@ -41,6 +58,7 @@ HEIR_ADDRESS = 0
 HEIR_AMOUNT = 1
 HEIR_LOCKTIME = 2
 HEIR_REAL_AMOUNT = 3
+HEIR_DUST_AMOUNT = 4
 TRANSACTION_LABEL = "inheritance transaction"
 
 
@@ -54,28 +72,22 @@ def reduce_outputs(in_amount, out_amount, fee, outputs):
             output.value = math.floor((in_amount - fee) / out_amount * output.value)
 
 
-"""
-#TODO: put this method inside wallet.db to replace or complete get_locktime_for_new_transaction
-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
-"""
-
+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
+        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(
@@ -84,39 +96,45 @@ def prepare_transactions(locktimes, available_utxos, fees, wallet):
             x.value_sats(), x.prevout.txid, x.prevout.out_idx
         ),
     )
-    total_used_utxos = []
+    # total_used_utxos = []
     txsout = {}
     locktime, _ = Util.get_lowest_locktimes(locktimes)
     if not locktime:
+        _logger.info("prepare transactions, no locktime")
         return
     locktime = locktime[0]
 
     heirs = locktimes[locktime]
-    vero = True
-    while vero:
-        vero = False
+    true = True
+    while true:
+        true = False
         fee = fees.get(locktime, 0)
         out_amount = fee
         description = ""
         outputs = []
         paid_heirs = {}
         for name, heir in heirs.items():
-
-            try:
-                if len(heir) > HEIR_REAL_AMOUNT:
+            if len(heir) > HEIR_REAL_AMOUNT and "DUST" not in str(
+                heir[HEIR_REAL_AMOUNT]
+            ):
+                try:
                     real_amount = heir[HEIR_REAL_AMOUNT]
-                    out_amount += real_amount
-                    description += f"{name}\n"
-                    paid_heirs[name] = heir
                     outputs.append(
                         PartialTxOutput.from_address_and_value(
                             heir[HEIR_ADDRESS], real_amount
                         )
                     )
-                else:
+                    out_amount += real_amount
+                    description += f"{name}\n"
+                except BitcoinException as e:
+                    _logger.info("exception decoding output {} - {}".format(type(e), e))
+                    heir[HEIR_REAL_AMOUNT] = e
+
+                except Exception as e:
+                    heir[HEIR_REAL_AMOUNT] = e
+                    _logger.error(f"error preparing transactions: {e}")
                     pass
-            except Exception as e:
-                pass
+            paid_heirs[name] = heir
 
         in_amount = 0.0
         used_utxos = []
@@ -125,19 +143,32 @@ def prepare_transactions(locktimes, available_utxos, fees, wallet):
                 value = utxo.value_sats()
                 in_amount += value
                 used_utxos.append(utxo)
-                if in_amount > out_amount:
+                if in_amount >= out_amount:
                     break
 
         except IndexError as e:
+            _logger.error(
+                f"error preparing transactions index error {e} {in_amount}, {out_amount}"
+            )
             pass
         if int(in_amount) < int(out_amount):
-            break
+            _logger.error(
+                "error preparing transactions in_amount < out_amount ({} < {})      "
+            )
+            continue
         heirsvalue = out_amount
         change = get_change_output(wallet, in_amount, out_amount, fee)
         if change:
             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,
@@ -185,7 +216,7 @@ def get_utxos_from_inputs(tx_inputs, tx, utxos):
 
 # TODO calculate de minimum inputs to be invalidated
 def invalidate_inheritance_transactions(wallet):
-    listids = []
+    # listids = []
     utxos = {}
     dtxs = {}
     for k, v in wallet.get_all_labels().items():
@@ -214,7 +245,7 @@ def invalidate_inheritance_transactions(wallet):
     for key, value in utxos:
         for tx in value["txs"]:
             txid = tx.txid()
-            if not txid in invalidated:
+            if txid not in invalidated:
                 invalidated.append(tx.txid())
                 remaining[key] = value
 
@@ -222,10 +253,10 @@ def invalidate_inheritance_transactions(wallet):
 def print_transaction(heirs, tx, locktimes, tx_fees):
     jtx = tx.to_json()
     print(f"TX: {tx.txid()}\t-\tLocktime: {jtx['locktime']}")
-    print(f"---")
+    print("---")
     for inp in jtx["inputs"]:
         print(f"{inp['address']}: {inp['value_sats']}")
-    print(f"---")
+    print("---")
     for out in jtx["outputs"]:
         heirname = ""
         for key in heirs.keys():
@@ -247,7 +278,7 @@ def print_transaction(heirs, tx, locktimes, tx_fees):
     print()
     try:
         print(tx.serialize_to_network())
-    except:
+    except Exception:
         print("impossible to serialize")
     print()
 
@@ -263,13 +294,14 @@ def get_change_output(wallet, in_amount, out_amount, fee):
 
 class Heirs(dict, Logger):
 
-    def __init__(self, db: "WalletDB"):
+    def __init__(self, wallet):
         Logger.__init__(self)
-        self.db = db
+        self.db = wallet.db
+        self.wallet = wallet
         d = self.db.get("heirs", {})
         try:
             self.update(d)
-        except e as Exception:
+        except Exception:
             return
 
     def invalidate_transactions(self, wallet):
@@ -303,7 +335,7 @@ class Heirs(dict, Logger):
             locktime = Util.parse_locktime_string(self[key][HEIR_LOCKTIME])
             if locktime > from_locktime and not a or locktime <= from_locktime and a:
                 locktimes[int(locktime)] = None
-        return locktimes.keys()
+        return list(locktimes.keys())
 
     def check_locktime(self):
         return False
@@ -317,6 +349,8 @@ class Heirs(dict, Logger):
                 column = HEIR_AMOUNT
                 if real:
                     column = HEIR_REAL_AMOUNT
+                if "DUST" in str(v[column]):
+                    column = HEIR_DUST_AMOUNT
                 value = int(
                     math.floor(
                         total_balance
@@ -327,6 +361,10 @@ class Heirs(dict, Logger):
                 if value > wallet.dust_threshold():
                     heir_list[key].insert(HEIR_REAL_AMOUNT, value)
                     amount += value
+                else:
+                    heir_list[key].insert(HEIR_REAL_AMOUNT, f"DUST: {value}")
+                    heir_list[key].insert(HEIR_DUST_AMOUNT, value)
+                    _logger.info(f"{key}, {value} is dust will be ignored")
 
             except Exception as e:
                 raise e
@@ -335,10 +373,10 @@ class Heirs(dict, Logger):
     def amount_to_float(self, amount):
         try:
             return float(amount)
-        except:
+        except Exception:
             try:
                 return float(amount[:-1])
-            except:
+            except Exception:
                 return 0.0
 
     def fixed_percent_lists_amount(self, from_locktime, dust_threshold, reverse=False):
@@ -346,31 +384,50 @@ class Heirs(dict, Logger):
         fixed_amount = 0.0
         percent_heirs = {}
         percent_amount = 0.0
+        fixed_amount_with_dust = 0.0
         for key in self.keys():
             try:
                 cmp = (
                     Util.parse_locktime_string(self[key][HEIR_LOCKTIME]) - from_locktime
                 )
                 if cmp <= 0:
+                    _logger.debug(
+                        "cmp < 0 {} {} {} {}".format(
+                            cmp, key, self[key][HEIR_LOCKTIME], from_locktime
+                        )
+                    )
                     continue
                 if Util.is_perc(self[key][HEIR_AMOUNT]):
                     percent_amount += float(self[key][HEIR_AMOUNT][:-1])
                     percent_heirs[key] = list(self[key])
                 else:
                     heir_amount = int(math.floor(float(self[key][HEIR_AMOUNT])))
+                    fixed_amount_with_dust += heir_amount
+                    fixed_heirs[key] = list(self[key])
                     if heir_amount > dust_threshold:
                         fixed_amount += heir_amount
-                        fixed_heirs[key] = list(self[key])
                         fixed_heirs[key].insert(HEIR_REAL_AMOUNT, heir_amount)
                     else:
-                        pass
+                        fixed_heirs[key] = list(self[key])
+                        fixed_heirs[key].insert(
+                            HEIR_REAL_AMOUNT, f"DUST: {heir_amount}"
+                        )
+                        fixed_heirs[key].insert(HEIR_DUST_AMOUNT, heir_amount)
             except Exception as e:
                 _logger.error(e)
-        return fixed_heirs, fixed_amount, percent_heirs, percent_amount
+        return (
+            fixed_heirs,
+            fixed_amount,
+            percent_heirs,
+            percent_amount,
+            fixed_amount_with_dust,
+        )
 
     def prepare_lists(
         self, balance, total_fees, wallet, willexecutor=False, from_locktime=0
     ):
+        if balance<total_fees or balance < wallet.dust_threshold():
+            raise BalanceTooLowException(balance,wallet.dust_threshold(),total_fees)
         willexecutors_amount = 0
         willexecutors = {}
         heir_list = {}
@@ -391,7 +448,7 @@ class Heirs(dict, Logger):
                         willexecutors[
                             'w!ll3x3c"' + willexecutor["url"] + '"' + str(locktime)
                         ] = h
-                    except Exception as e:
+                    except Exception:
                         return [], False
                 else:
                     _logger.error(
@@ -399,9 +456,15 @@ class Heirs(dict, Logger):
                     ),
             heir_list.update(willexecutors)
             newbalance -= willexecutors_amount
-        fixed_heirs, fixed_amount, percent_heirs, percent_amount = (
-            self.fixed_percent_lists_amount(from_locktime, wallet.dust_threshold())
-        )
+            if newbalance < 0:
+                raise WillExecutorFeeException(willexecutor)
+        (
+            fixed_heirs,
+            fixed_amount,
+            percent_heirs,
+            percent_amount,
+            fixed_amount_with_dust,
+        ) = self.fixed_percent_lists_amount(from_locktime, wallet.dust_threshold())
         if fixed_amount > newbalance:
             fixed_amount = self.normalize_perc(
                 fixed_heirs, newbalance, fixed_amount, wallet
@@ -411,18 +474,16 @@ class Heirs(dict, Logger):
         heir_list.update(fixed_heirs)
 
         newbalance -= fixed_amount
-
         if newbalance > 0:
             perc_amount = self.normalize_perc(
                 percent_heirs, newbalance, percent_amount, wallet
             )
             newbalance -= perc_amount
             heir_list.update(percent_heirs)
-
         if newbalance > 0:
             newbalance += fixed_amount
             fixed_amount = self.normalize_perc(
-                fixed_heirs, newbalance, fixed_amount, wallet, real=True
+                fixed_heirs, newbalance, fixed_amount_with_dust, wallet, real=True
             )
             newbalance -= fixed_amount
             heir_list.update(fixed_heirs)
@@ -435,7 +496,7 @@ class Heirs(dict, Logger):
         locktimes = {}
         for key, value in heir_list:
             locktime = Util.parse_locktime_string(value[HEIR_LOCKTIME])
-            if not locktime in locktimes:
+            if locktime not in locktimes:
                 locktimes[locktime] = {key: value}
             else:
                 locktimes[locktime][key] = value
@@ -449,6 +510,7 @@ class Heirs(dict, Logger):
     ):
         Heirs._validate(self)
         if len(self) <= 0:
+            _logger.info("while building transactions there was no heirs")
             return
         balance = 0.0
         len_utxo_set = 0
@@ -464,6 +526,7 @@ class Heirs(dict, Logger):
                 len_utxo_set += 1
                 available_utxos.append(utxo)
         if len_utxo_set == 0:
+            _logger.info("no usable utxos")
             return
         j = -2
         willexecutorsitems = list(willexecutors.items())
@@ -475,7 +538,7 @@ class Heirs(dict, Logger):
                 break
             elif 0 <= j:
                 url, willexecutor = willexecutorsitems[j]
-                if not Willexecutors.is_selected(willexecutor):
+                if not Willexecutors.is_selected(willexecutor) or willexecutor["base_fee"] < wallet.dust_threshold():
                     continue
                 else:
                     willexecutor["url"] = url
@@ -487,51 +550,66 @@ class Heirs(dict, Logger):
                 break
             fees = {}
             i = 0
-            while True:
+            while i < 10:
                 txs = {}
                 redo = False
                 i += 1
                 total_fees = 0
                 for fee in fees:
                     total_fees += int(fees[fee])
-                newbalance = balance
-                locktimes, onlyfixed = self.prepare_lists(
-                    balance, total_fees, wallet, willexecutor, from_locktime
-                )
+                # newbalance = balance
                 try:
-                    txs = prepare_transactions(
-                        locktimes, available_utxos[:], fees, wallet
+                    locktimes, onlyfixed = self.prepare_lists(
+                        balance, total_fees, wallet, willexecutor, from_locktime
                     )
-                    if not txs:
-                        return {}
-                except Exception as e:
+                except WillExecutorFeeException:
+                    i = 10
+                    continue
+                if locktimes:
                     try:
-                        if "w!ll3x3c" in e.heirname:
-                            Willexecutors.is_selected(willexecutors[w], False)
-                            break
-                    except:
-                        raise e
-                total_fees = 0
-                total_fees_real = 0
-                total_in = 0
-                for txid, tx in txs.items():
-                    tx.willexecutor = willexecutor
-                    fee = tx.estimated_size() * tx_fees
-                    txs[txid].tx_fees = tx_fees
-                    total_fees += fee
-                    total_fees_real += tx.get_fee()
-                    total_in += tx.input_value()
-                    rfee = tx.input_value() - tx.output_value()
-                    if rfee < fee or rfee > fee + wallet.dust_threshold():
-                        redo = True
-                    oldfees = fees.get(tx.my_locktime, 0)
-                    fees[tx.my_locktime] = fee
+                        txs = prepare_transactions(
+                            locktimes, available_utxos[:], fees, wallet
+                        )
+                        if not txs:
+                            return {}
+                    except Exception as e:
+                        _logger.error(
+                            f"build transactions: error preparing transactions: {e}"
+                        )
+                        try:
+                            if "w!ll3x3c" in e.heirname:
+                                Willexecutors.is_selected(
+                                    e.heirname[len("w!ll3x3c") :], False
+                                )
+                                break
+                        except Exception:
+                            raise e
+                    total_fees = 0
+                    total_fees_real = 0
+                    total_in = 0
+                    for txid, tx in txs.items():
+                        tx.willexecutor = willexecutor
+                        fee = tx.estimated_size() * tx_fees
+                        txs[txid].tx_fees = tx_fees
+                        total_fees += fee
+                        total_fees_real += tx.get_fee()
+                        total_in += tx.input_value()
+                        rfee = tx.input_value() - tx.output_value()
+                        if rfee < fee or rfee > fee + wallet.dust_threshold():
+                            redo = True
+                        # oldfees = fees.get(tx.my_locktime, 0)
+                        fees[tx.my_locktime] = fee
 
-                if balance - total_in > wallet.dust_threshold():
-                    redo = True
-                if not redo:
-                    break
-                if i >= 10:
+                    if balance - total_in > wallet.dust_threshold():
+                        redo = True
+                    if not redo:
+                        break
+                    if i >= 10:
+                        break
+                else:
+                    _logger.info(
+                        f"no locktimes for willexecutor {willexecutor} skipped"
+                    )
                     break
             alltxs.update(txs)
 
@@ -632,7 +710,7 @@ class Heirs(dict, Logger):
             return None
 
     def validate_address(address):
-        if not bitcoin.is_address(address):
+        if not bitcoin.is_address(address, net=constants.net):
             raise NotAnAddress(f"not an address,{address}")
         return address
 
@@ -661,12 +739,14 @@ class Heirs(dict, Logger):
         return (address, amount, locktime)
 
     def _validate(data, timestamp_to_check=False):
+
         for k, v in list(data.items()):
             if k == "heirs":
-                return Heirs._validate(v)
+                return Heirs._validate(v, timestamp_to_check)
             try:
-                Heirs.validate_heir(k, v)
+                Heirs.validate_heir(k, v, timestamp_to_check)
             except Exception as e:
+                _logger.info(f"exception heir removed {e}")
                 data.pop(k)
         return data
 
@@ -685,3 +765,28 @@ class LocktimeNotValid(ValueError):
 
 class HeirExpiredException(LocktimeNotValid):
     pass
+
+
+class HeirAmountIsDustException(Exception):
+    pass
+
+
+class NoHeirsException(Exception):
+    pass
+
+
+class WillExecutorFeeException(Exception):
+    def __init__(self, willexecutor):
+        self.willexecutor = willexecutor
+
+    def __str__(self):
+        return "WillExecutorFeeException: {} fee:{}".format(
+            self.willexecutor["url"], self.willexecutor["base_fee"]
+        )
+class BalanceTooLowException(Exception):
+    def __init__(self,balance, dust_threshold, fees):
+        self.balance=balance
+        self.dust_threshold = dust_threshold
+        self.fees = fees
+    def __str__(self):
+        return f"Balance too low, balance: {self.balance}, dust threshold: {self.dust_threshold}, fees: {self.fees}"

manifest.json

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

util.py

@@ -1,45 +1,97 @@
+# -*- coding: utf-8 -*-
+
+# Utility module for the BAL Electrum plugin.
+
 import bisect
-import urllib.parse
-import urllib.request
 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, FileImportFailed, write_json_file
+from electrum.util import FileExportFailed
 
 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:
                 dt = datetime.fromtimestamp(locktime).isoformat()
                 return dt
 
-        except Exception as e:
+        except Exception:
             pass
         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
             else:
                 return int(locktime)
-        except Exception as e:
+        except Exception:
             pass
         dt_object = datetime.fromisoformat(locktime)
         timestamp = dt_object.timestamp()
         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)
 
-        except Exception as e:
+        except Exception:
             pass
         try:
             now = datetime.now()
@@ -58,11 +110,26 @@ class Util:
                     height = Util.get_current_height(w.network)
                 locktime += int(height)
             return int(locktime)
-        except Exception as e:
+        except Exception:
             pass
         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
@@ -72,45 +139,114 @@ 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:
             try:
                 return int(float(amount) * pow(10, decimal_point))
-            except:
+            except Exception:
                 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:
-            num = 8 - decimal_point
-            basestr = "{{:0{}.{}f}}".format(num, num)
-            return "{:08.8f}".format(float(amount) / pow(10, decimal_point))
+            basestr = "{{:0.{}f}}".format(decimal_point)
+            try:
+                return basestr.format(float(amount) / pow(10, decimal_point))
+            except Exception:
+                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:
+        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 not len(heira) == len(heirb):
+            if len(heira) != len(heirb):
                 return False
             for h in range(0, len(heira)):
-                if not heira[h] == heirb[h]:
+                if heira[h] != heirb[h]:
                     return False
             return True
-        except:
+        except Exception:
             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:
@@ -120,11 +256,24 @@ class Util:
                 and willexecutora["base_fee"] == willexecutorb["base_fee"]
             ):
                 return True
-        except:
+        except Exception:
             return False
         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:
@@ -136,6 +285,16 @@ 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
@@ -144,9 +303,27 @@ 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 not 'w!ll3x3c"' in heira
+                exclude_willexecutors and 'w!ll3x3c"' not in heira
             ) or not exclude_willexecutors:
                 found = False
                 for heirb in heirsb:
@@ -171,10 +348,30 @@ 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 not 'w!ll3x3c"' in heir:
-                    if not heir in heirsb or not cmp_function(
+                if 'w!ll3x3c"' not in heir:
+                    if heir not in heirsb or not cmp_function(
                         heirsa[heir], heirsb[heir]
                     ):
                         if not Util.search_heir_by_values(heirsb, heirsa[heir], [0, 3]):
@@ -188,6 +385,16 @@ 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:
@@ -196,6 +403,21 @@ 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:
@@ -205,6 +427,15 @@ 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()):
@@ -212,8 +443,22 @@ 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()
+        # outputsb = txb.outputs()
         value_amount = 0
 
         for outa in outputsa:
@@ -230,6 +475,24 @@ 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:
@@ -240,6 +503,25 @@ 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:
@@ -256,12 +538,24 @@ 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
-        strlocktime = str(locktimea)
+        strlocktimea = str(locktimea)
         strlocktimeb = str(locktimeb)
-        intlocktimea = Util.str_to_locktime(strlocktimea)
-        intlocktimeb = Util.str_to_locktime(strlocktimeb)
+        # intlocktimea = Util.str_to_locktime(strlocktimea)
+        # intlocktimeb = Util.str_to_locktime(strlocktimeb)
         if locktimea[-1] in "ydb":
             if locktimeb[-1] == locktimea[-1]:
                 return int(strlocktimea[-1]) - int(strlocktimeb[-1])
@@ -269,41 +563,111 @@ 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 l in locktimes:
-            l = Util.parse_locktime_string(l)
-            if l < LOCKTIME_THRESHOLD:
-                bisect.insort(sorted_block, l)
+        for locktime in locktimes:
+            locktime = Util.parse_locktime_string(locktime)
+            if locktime < LOCKTIME_THRESHOLD:
+                bisect.insort(sorted_block, locktime)
             else:
-                bisect.insort(sorted_timestamp, l)
+                bisect.insort(sorted_timestamp, locktime)
 
         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()
@@ -311,17 +675,37 @@ 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 as e:
+        except Exception:
             pass
         try:
             return utxo.prevout.to_str()
-        except Exception as e:
+        except Exception:
             pass
         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:
@@ -330,21 +714,57 @@ 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
@@ -356,6 +776,22 @@ 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):
@@ -371,6 +807,22 @@ 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()
@@ -380,7 +832,19 @@ class Util:
             out.is_change = True
             return out
 
-    def get_current_height(network: "Network"):
+    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
@@ -402,44 +866,59 @@ 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 not var is None:
-            try:
-                print("doc:", doc(var))
-            except:
-                pass
+        if var is not None:
             try:
                 print("str:", str(var))
-            except:
+            except Exception:
                 pass
             try:
                 print("repr", repr(var))
-            except:
+            except Exception:
                 pass
             try:
                 print("dict", dict(var))
-            except:
+            except Exception:
                 pass
             try:
                 print("dir", dir(var))
-            except:
+            except Exception:
                 pass
             try:
                 print("type", type(var))
-            except:
+            except Exception:
                 pass
             try:
                 print("to_json", var.to_json())
-            except:
+            except Exception:
                 pass
             try:
                 print("__slotnames__", var.__slotnames__)
-            except:
+            except Exception:
                 pass
 
         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)
@@ -451,16 +930,33 @@ 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: "ElectrumWindow", title, exporter):
+    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),
+            title=_("Select file to save your {}".format(title)),
             filename="BALplugin_{}".format(title),
             filter=filter_,
             config=electrum_window.config,
@@ -473,14 +969,31 @@ class Util:
             electrum_window.show_critical(str(e))
         else:
             electrum_window.show_message(
-                _("Your {0} were exported to '{1}'").format(title, str(filename))
+                _("Your {0} were exported to '{1}'".format(title, str(filename)))
             )
 
     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:
@@ -490,6 +1003,17 @@ 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)
@@ -498,3 +1022,30 @@ 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"

wallet_util/bal_wallet_utils.py

@@ -1,7 +1,7 @@
 #!env/bin/python3
 from electrum.storage import WalletStorage
-from electrum.util import MyEncoder
 import json
+from electrum.util import MyEncoder
 import sys
 import getpass
 import os
@@ -47,12 +47,12 @@ def save(json_wallet, storage):
 def read_wallet(path, password=False):
     storage = WalletStorage(path)
     if storage.is_encrypted():
-        if password == False:
+        if not password:
             password = getpass.getpass("Enter wallet password: ", stream=None)
         storage.decrypt(password)
     data = storage.read()
     json_wallet = json.loads("[" + data + "]")[0]
-    return json_wallet
+    return json_wallet, storage
 
 
 if __name__ == "__main__":
@@ -65,7 +65,7 @@ if __name__ == "__main__":
         exit(1)
     command = sys.argv[1]
     path = sys.argv[2]
-    json_wallet = read_wallet(path)
+    json_wallet, storage = read_wallet(path)
     have_to_save = False
     if command == "fix":
         have_to_save = fix_will_settings_tx_fees(json_wallet)

wallet_util/bal_wallet_utils_qt.py

@@ -15,10 +15,8 @@ from PyQt6.QtWidgets import (
     QGroupBox,
     QTextEdit,
 )
-from PyQt6.QtCore import Qt
 from electrum.storage import WalletStorage
-from electrum.util import MyEncoder
-from bal_wallet_utils import fix_will_settings_tx_fees, uninstall_bal, read_wallet, save
+from bal_wallet_utils import fix_will_settings_tx_fees, uninstall_bal, save
 
 
 class WalletUtilityGUI(QMainWindow):
@@ -190,14 +188,6 @@ class WalletUtilityGUI(QMainWindow):
 def main():
     app = QApplication(sys.argv)
 
-    # Check if dependencies are available
-    try:
-        from electrum.storage import WalletStorage
-        from electrum.util import MyEncoder
-    except ImportError as e:
-        print(f"ERROR: Cannot import Electrum dependencies: {str(e)}")
-        return 1
-
     window = WalletUtilityGUI()
     window.show()
 

will.py

@@ -1,3 +1,11 @@
+# -*- 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
@@ -12,11 +20,7 @@ from electrum.transaction import (
     tx_from_any,
 )
 from electrum.util import (
-    FileImportFailed,
     bfh,
-    decimal_point_to_base_unit_name,
-    read_json_file,
-    write_json_file,
 )
 
 from .util import Util
@@ -28,7 +32,6 @@ _logger = get_logger(__name__)
 
 
 class Will:
-    # return an array with the list of children
     def get_children(will, willid):
         out = []
         for _id in will:
@@ -82,13 +85,11 @@ class Will:
         for txin in will[wid].tx.inputs():
             txid = txin.prevout.txid.hex()
             if txid in will:
-                # print(will[txid].tx.outputs())
-                # print(txin.prevout.out_idx)
                 change = will[txid].tx.outputs()[txin.prevout.out_idx]
                 txin._trusted_value_sats = change.value
                 try:
                     txin.script_descriptor = change.script_descriptor
-                except:
+                except Exception:
                     pass
                 txin.is_mine = True
                 txin._TxInput__address = change.address
@@ -135,8 +136,8 @@ class Will:
                 to_delete.append(wid)
                 to_add[ow.tx.txid()] = ow.to_dict()
 
-        for eid, err in errors.items():
-            new_txid = err.tx.txid()
+        # for eid, err in errors.items():
+        #    new_txid = err.tx.txid()
 
         for k, w in to_add.items():
             will[k] = w
@@ -155,6 +156,16 @@ class Will:
         inp._TxInput__value_sats = change.value
         return inp
 
+    """
+    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):
@@ -194,7 +205,7 @@ class Will:
                 outputs = w.tx.outputs()
                 found = False
                 old_txid = w.tx.txid()
-                ntx = None
+                # ntx = None
                 for i in range(0, len(inputs)):
                     if (
                         inputs[i].prevout.txid.hex() == otxid
@@ -205,7 +216,7 @@ class Will:
                             will[wid].tx.set_rbf(True)
                         will[wid].tx._inputs[i] = Will.new_input(wid, idx, change)
                         found = True
-                if found == True:
+                if found:
                     pass
 
                 new_txid = will[wid].tx.txid()
@@ -232,7 +243,7 @@ class Will:
                 for i in inputs:
                     prevout_str = i.prevout.to_str()
                     inp = [w, will[w], i]
-                    if not prevout_str in all_inputs:
+                    if prevout_str not in all_inputs:
                         all_inputs[prevout_str] = [inp]
                     else:
                         all_inputs[prevout_str].append(inp)
@@ -245,7 +256,7 @@ class Will:
             min_locktime = min(values, key=lambda x: x[1].tx.locktime)[1].tx.locktime
             for w in values:
                 if w[1].tx.locktime == min_locktime:
-                    if not i in all_inputs_min_locktime:
+                    if i not in all_inputs_min_locktime:
                         all_inputs_min_locktime[i] = [w]
                     else:
                         all_inputs_min_locktime[i].append(w)
@@ -258,7 +269,7 @@ class Will:
         to_append = {}
         new_inputs = Will.get_all_inputs(will, only_valid=True)
         for nid, nwi in will.items():
-            if nwi.search_anticipate(new_inputs) or nwi.search_anticipate(old_inputs):
+            if nwi.search_anticipate(new_inputs):
                 if nid != nwi.tx.txid():
                     redo = True
                     to_delete.append(nid)
@@ -268,25 +279,36 @@ class Will:
                         Will.change_input(
                             will, nid, i, outputs[i], new_inputs, to_delete, to_append
                         )
+            if nwi.search_anticipate(old_inputs):
+                if nid != nwi.tx.txid():
+                    redo = True
+
+                    to_delete.append(nid)
+                    to_append[nwi.tx.txid()] = nwi
+                    outputs = nwi.tx.outputs()
+                    for i in range(0, len(outputs)):
+                        Will.change_input(
+                            will, nid, i, outputs[i], new_inputs, to_delete, to_append
+                        )
 
         for w in to_delete:
             try:
                 del will[w]
-            except:
+            except Exception:
                 pass
         for k, w in to_append.items():
             will[k] = w
         if redo:
+
             Will.search_anticipate_rec(will, old_inputs)
 
     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)
-        all_new_inputs = Will.get_all_inputs(new_will)
+        # all_inputs_min_locktime = Will.get_all_inputs_min_locktime(all_old_inputs)
+        # all_new_inputs = Will.get_all_inputs(new_will)
         # check if the new input is already spent by other transaction
         # if it is use the same locktime, or anticipate.
         Will.search_anticipate_rec(new_will, all_old_inputs)
-
         other_inputs = Will.get_all_inputs(old_will, {})
         try:
             Will.normalize_will(new_will, others_inputs=other_inputs)
@@ -325,15 +347,18 @@ class Will:
         utxos = wallet.get_utxos()
         filtered_inputs = []
         prevout_to_spend = []
+        current_height = Util.get_current_height(wallet.network)
         for prevout_str, ws in inputs.items():
             for w in ws:
-                if not w[0] in filtered_inputs:
+                if w[0] not in filtered_inputs:
                     filtered_inputs.append(w[0])
-                    if not prevout_str in prevout_to_spend:
+                    if prevout_str not in prevout_to_spend:
                         prevout_to_spend.append(prevout_str)
         balance = 0
         utxo_to_spend = []
         for utxo in utxos:
+            if utxo.is_coinbase_output() and utxo.block_height < current_height+100:
+                continue
             utxo_str = utxo.prevout.to_str()
             if utxo_str in prevout_to_spend:
                 balance += inputs[utxo_str][0][2].value_sats()
@@ -342,7 +367,7 @@ class Will:
             change_addresses = wallet.get_change_addresses_for_new_transaction()
             out = PartialTxOutput.from_address_and_value(change_addresses[0], balance)
             out.is_change = True
-            locktime = Util.get_current_height(wallet.network)
+            locktime = current_height
             tx = PartialTransaction.from_io(
                 utxo_to_spend, [out], locktime=locktime, version=2
             )
@@ -373,7 +398,7 @@ class Will:
                 return True
 
     def search_rai(all_inputs, all_utxos, will, wallet):
-        will_only_valid = Will.only_valid_or_replaced_list(will)
+        # will_only_valid = Will.only_valid_or_replaced_list(will)
         for inp, ws in all_inputs.items():
             inutxo = Util.in_utxo(inp, all_utxos)
             for w in ws:
@@ -411,7 +436,7 @@ class Will:
     def set_invalidate(wid, will=[]):
         will[wid].set_status("INVALIDATED", True)
         if will[wid].children:
-            for c in self.children.items():
+            for c in will[wid].children.items():
                 Will.set_invalidate(c[0], will)
 
     def check_tx_height(tx, wallet):
@@ -421,10 +446,14 @@ class Will:
     # check if transactions are stil valid tecnically valid
     def check_invalidated(willtree, utxos_list, wallet):
         for wid, w in willtree.items():
-            if not w.father:
+            if (
+                not w.father
+                or willtree[w.father].get_status("CONFIRMED")
+                or willtree[w.father].get_status("PENDING")
+            ):
                 for inp in w.tx.inputs():
                     inp_str = Util.utxo_to_str(inp)
-                    if not inp_str in utxos_list:
+                    if inp_str not in utxos_list:
                         if wallet:
                             height = Will.check_tx_height(w.tx, wallet)
                             if height < 0:
@@ -434,21 +463,21 @@ class Will:
                             else:
                                 w.set_status("CONFIRMED", True)
 
-    def reflect_to_children(treeitem):
-        if not treeitem.get_status("VALID"):
-            _logger.debug(f"{tree:item._id} status not valid looking for children")
-            for child in treeitem.children:
-                wc = willtree[child]
-                if wc.get_status("VALID"):
-                    if treeitem.get_status("INVALIDATED"):
-                        wc.set_status("INVALIDATED", True)
-                    if treeitem.get_status("REPLACED"):
-                        wc.set_status("REPLACED", True)
-                        if wc.children:
-                            Will.reflect_to_children(wc)
+    # def reflect_to_children(treeitem):
+    #    if not treeitem.get_status("VALID"):
+    #        _logger.debug(f"{tree:item._id} status not valid looking for children")
+    #        for child in treeitem.children:
+    #            wc = willtree[child]
+    #            if wc.get_status("VALID"):
+    #                if treeitem.get_status("INVALIDATED"):
+    #                    wc.set_status("INVALIDATED", True)
+    #                if treeitem.get_status("REPLACED"):
+    #                    wc.set_status("REPLACED", True)
+    #                    if wc.children:
+    #                        Will.reflect_to_children(wc)
 
     def check_amounts(heirs, willexecutors, all_utxos, timestamp_to_check, dust):
-        fixed_heirs, fixed_amount, perc_heirs, perc_amount = (
+        fixed_heirs, fixed_amount, perc_heirs, perc_amount, fixed_amount_with_dust = (
             heirs.fixed_percent_lists_amount(timestamp_to_check, dust, reverse=True)
         )
         wallet_balance = 0
@@ -542,17 +571,20 @@ class Will:
                             raise WillExpiredException(
                                 f"Will Expired {wid[0][0]}: {locktime}<{timestamp_to_check}"
                             )
+                        else:
+                            from datetime import datetime
+                            _logger.debug(f"Will Not Expired {wid[0][0]}: {datetime.fromtimestamp(locktime).isoformat()} > {datetime.fromtimestamp(timestamp_to_check).isoformat()}")
 
-    def check_all_input_spent_are_in_wallet():
-        _logger.info("check all input spent are in wallet or valid txs")
-        for inp, ws in all_inputs.items():
-            if not Util.in_utxo(inp, all_utxos):
-                for w in ws:
-                    if w[1].get_status("VALID"):
-                        prevout_id = w[2].prevout.txid.hex()
-                        parentwill = will.get(prevout_id, False)
-                        if not parentwill or not parentwill.get_status("VALID"):
-                            w[1].set_status("INVALIDATED", True)
+    # def check_all_input_spent_are_in_wallet():
+    #    _logger.info("check all input spent are in wallet or valid txs")
+    #    for inp, ws in all_inputs.items():
+    #        if not Util.in_utxo(inp, all_utxos):
+    #            for w in ws:
+    #                if w[1].get_status("VALID"):
+    #                    prevout_id = w[2].prevout.txid.hex()
+    #                    parentwill = will.get(prevout_id, False)
+    #                    if not parentwill or not parentwill.get_status("VALID"):
+    #                        w[1].set_status("INVALIDATED", True)
 
     def only_valid_list(will):
         out = {}
@@ -598,9 +630,9 @@ class Will:
                             heirs_found[wheir] = count + 1
                     else:
                         _logger.debug(
-                            "heir not present transaction is not valid:", wid, w
+                            f"heir not present transaction is not valid:{wheir} {wid}, {w}"
                         )
-                        continue
+
             if willexecutor := w.we:
                 count = willexecutors_found.get(willexecutor["url"], 0)
                 if Util.cmp_willexecutor(
@@ -612,19 +644,19 @@ class Will:
                 no_willexecutor += 1
         count_heirs = 0
         for h in heirs:
+
             if Util.parse_locktime_string(heirs[h][2]) >= check_date:
                 count_heirs += 1
-                if not h in heirs_found:
+                if h not in heirs_found:
                     _logger.debug(f"heir: {h} not found")
                     raise HeirNotFoundException(h)
         if not count_heirs:
             raise NoHeirsException("there are not valid heirs")
         if self_willexecutor and no_willexecutor == 0:
             raise NoWillExecutorNotPresent("Backup tx")
-
         for url, we in willexecutors.items():
             if Willexecutors.is_selected(we):
-                if not url in willexecutors_found:
+                if url not in willexecutors_found:
                     _logger.debug(f"will-executor: {url} not fount")
                     raise WillExecutorNotPresent(url)
         _logger.info("will is coherent with heirs and will-executors")
@@ -632,7 +664,6 @@ class Will:
 
 
 class WillItem(Logger):
-
     STATUS_DEFAULT = {
         "ANTICIPATED": ["Anticipated", False],
         "BROADCASTED": ["Broadcasted", False],
@@ -654,15 +685,15 @@ class WillItem(Logger):
     }
 
     def set_status(self, status, value=True):
-        #_logger.trace(
+        # _logger.trace(
         #    "set status {} - {} {} -> {}".format(
         #        self._id, status, self.STATUS[status][1], value
         #    )
-        #)
+        # )
         if self.STATUS[status][1] == bool(value):
             return None
 
-        self.status += "." + ("NOT " if not value else "" + _(self.STATUS[status][0]))
+        self.status += "." + (("NOT " if not value else "") + _(self.STATUS[status][0]))
         self.STATUS[status][1] = bool(value)
         if value:
             if status in ["INVALIDATED", "REPLACED", "CONFIRMED", "PENDING"]:
@@ -776,9 +807,9 @@ class WillItem(Logger):
                     iw = inp[1]
                     self.set_anticipate(iw)
 
-    def check_willexecutor(self):
+    def set_check_willexecutor(self,resp):
         try:
-            if resp := Willexecutors.check_transaction(self._id, self.we["url"]):
+            if resp :
                 if "tx" in resp and resp["tx"] == str(self.tx):
                     self.set_status("PUSHED")
                     self.set_status("CHECKED")
@@ -818,7 +849,12 @@ class WillItem(Logger):
 
 
 class WillException(Exception):
-    pass
+    def __init__(self,msg="WillException"):
+        self.msg=msg
+        Exception.__init__(self)
+    def __str__(self):
+        return self.msg
+
 
 
 class WillExpiredException(WillException):
@@ -855,8 +891,6 @@ class WillExecutorNotPresent(NotCompleteWillException):
 
 class NoHeirsException(WillException):
     pass
-
-
 class AmountException(WillException):
     pass
 

willexecutors.py

@@ -1,33 +1,70 @@
+"""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
-from functools import partial
+import time
 
 from aiohttp import ClientResponse
 from electrum import constants
-from electrum.gui.qt.util import WaitingDialog
 from electrum.i18n import _
 from electrum.logging import get_logger
 from electrum.network import Network
 
 from .bal import BalPlugin
-from .util import Util
 
 DEFAULT_TIMEOUT = 5
 _logger = get_logger(__name__)
 
 
+chainname = constants.net.NET_NAME if constants.net.NET_NAME != "mainnet" else "bitcoin"
+
+
 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[constants.net.NET_NAME] = willexecutors
+        aw[chainname] = willexecutors
         bal_plugin.WILLEXECUTORS.set(aw)
+        _logger.debug(f"saved: {aw}")
+        # bal_plugin.WILLEXECUTORS.set(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(constants.net.NET_NAME, {})
+        willexecutors = willexecutors.get(chainname, {})
         to_del = []
         for w in willexecutors:
             if not isinstance(willexecutors[w], dict):
@@ -35,34 +72,38 @@ class Willexecutors:
                 continue
             Willexecutors.initialize_willexecutor(willexecutors[w], w)
         for w in to_del:
-            _logger.error("error Willexecutor to delete type:{} ", type(willexecutor[w]),w)
+            _logger.error(
+                "error Willexecutor to delete type:{} {}".format(
+                    type(willexecutors[w]), w
+                )
+            )
             del willexecutors[w]
-        bal = bal_plugin.WILLEXECUTORS.default.get(constants.net.NET_NAME, {})
+        bal = bal_plugin.WILLEXECUTORS.default.get(chainname, {})
         for bal_url, bal_executor in bal.items():
-            if not bal_url in willexecutors:
+            if bal_url not in willexecutors:
                 _logger.debug(f"force add {bal_url} willexecutor")
                 willexecutors[bal_url] = bal_executor
-        if update:
-            found = False
-            for url, we in willexecutors.items():
-                if Willexecutors.is_selected(we):
-                    found = True
-            if found or force:
-                if bal_plugin.PING_WILLEXECUTORS.get() or force:
-                    ping_willexecutors = True
-                    if bal_plugin.ASK_PING_WILLEXECUTORS.get() and not force:
-                        if bal_window:
-                            ping_willexecutors = bal_window.window.question(
-                                _(
-                                    "Contact willexecutors servers to update payment informations?"
-                                )
-                            )
+        # if update:
+        #    found = False
+        #    for url, we in willexecutors.items():
+        #        if Willexecutors.is_selected(we):
+        #            found = True
+        #    if found or force:
+        #        if bal_plugin.PING_WILLEXECUTORS.get() or force:
+        #            ping_willexecutors = True
+        #            if bal_plugin.ASK_PING_WILLEXECUTORS.get() and not force:
+        #                if bal_window:
+        #                    ping_willexecutors = bal_window.window.question(
+        #                        _(
+        #                            "Contact willexecutors servers to update payment informations?"
+        #                        )
+        #                    )
 
-                    if ping_willexecutors:
-                        if task:
-                            bal_window.ping_willexecutors(willexecutors, task)
-                        else:
-                            bal_window.ping_willexecutors_task(willexecutors)
+        #            if ping_willexecutors:
+        #                if task:
+        #                    bal_window.ping_willexecutors(willexecutors, task)
+        #                else:
+        #                    bal_window.ping_willexecutors_task(willexecutors)
         w_sorted = dict(
             sorted(
                 willexecutors.items(), key=lambda w: w[1].get("sort", 0), reverse=True
@@ -71,17 +112,35 @@ 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 not value is None:
+        if value is not None:
             willexecutor["selected"] = value
         try:
             return willexecutor["selected"]
-        except:
+        except Exception:
             willexecutor["selected"] = False
             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"):
@@ -90,7 +149,7 @@ class Willexecutors:
                         if willexecutor := willitem.we:
                             url = willexecutor["url"]
                             if willexecutor and Willexecutors.is_selected(willexecutor):
-                                if not url in willexecutors:
+                                if url not in willexecutors:
                                     willexecutor["txs"] = ""
                                     willexecutor["txsids"] = []
                                     willexecutor["broadcast_status"] = _("Waiting...")
@@ -100,31 +159,50 @@ class Willexecutors:
 
         return willexecutors
 
-    def only_selected_list(willexecutors):
-        out = {}
-        for url, v in willexecutors.items():
-            if Willexecutors.is_selected(willexecutor):
-                out[url] = v
+    # def only_selected_list(willexecutors):
+    #    out = {}
+    #    for url, v in willexecutors.items():
+    #        if Willexecutors.is_selected(url):
+    #            out[url] = v
 
-    def push_transactions_to_willexecutors(will):
-        willexecutors = get_transactions_to_be_pushed()
-        for url in willexecutors:
-            willexecutor = willexecutors[url]
-            if Willexecutors.is_selected(willexecutor):
-                if "txs" in willexecutor:
-                    Willexecutors.push_transactions_to_willexecutor(
-                        willexecutors[url]["txs"], url
-                    )
+    # def push_transactions_to_willexecutors(will):
+    #    willexecutors = Willexecutors.get_transactions_to_be_pushed()
+    #    for url in willexecutors:
+    #        willexecutor = willexecutors[url]
+    #        if Willexecutors.is_selected(willexecutor):
+    #            if "txs" in willexecutor:
+    #                Willexecutors.push_transactions_to_willexecutor(
+    #                    willexecutors[url]["txs"], url
+    #                )
 
-    def send_request(method, url, data=None, *, timeout=10):
+    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 ErrorConnectingServer("You are offline.")
+            raise Exception("You are offline.")
         _logger.debug(f"<-- {method} {url} {data}")
         headers = {}
-        headers["user-agent"] = f"BalPlugin v:{BalPlugin.version()}"
+        headers["user-agent"] = f"BalPlugin v:{BalPlugin.__version__}"
         headers["Content-Type"] = "text/plain"
-
+        if not handle_response:
+            handle_response = Willexecutors.handle_response
         try:
             if method == "get":
                 response = Network.send_http_on_proxy(
@@ -132,7 +210,7 @@ class Willexecutors:
                     url,
                     params=data,
                     headers=headers,
-                    on_finish=Willexecutors.handle_response,
+                    on_finish=handle_response,
                     timeout=timeout,
                 )
             elif method == "post":
@@ -141,40 +219,88 @@ class Willexecutors:
                     url,
                     body=data,
                     headers=headers,
-                    on_finish=Willexecutors.handle_response,
+                    on_finish=handle_response,
                     timeout=timeout,
                 )
             else:
                 raise Exception(f"unexpected {method=!r}")
+        except TimeoutError:
+            if count_reply < 10:
+                _logger.debug(f"timeout({count_reply}) error: retry in 3 sec...")
+                time.sleep(3)
+                return Willexecutors.send_request(
+                    method,
+                    url,
+                    data,
+                    timeout=timeout,
+                    handle_response=handle_response,
+                    count_reply=count_reply + 1,
+                )
+            else:
+                _logger.debug(f"Too many timeouts: {count_reply}")
         except Exception as e:
-            _logger.error(f"exception sending request {e}")
             raise e
         else:
             _logger.debug(f"--> {response}")
             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:
+
             r = json.loads(r)
-            r["status"] = resp.status
-            r["selected"] = Willexecutors.is_selected(willexecutor)
-            r["url"] = url
-        except:
+            # url = Willexecutors.get_we_url_from_response(resp)
+            # r["url"]= url
+            # r["status"]=resp.status
+        except Exception as e:
+            _logger.debug(f"error handling response:{e}")
             pass
         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['txs']")
+            _logger.debug(f"{willexecutor['url']}: {willexecutor['txs']}")
             if w := Willexecutors.send_request(
                 "post",
-                willexecutor["url"] + "/" + constants.net.NET_NAME + "/pushtxs",
+                willexecutor["url"] + "/" + chainname + "/pushtxs",
                 data=willexecutor["txs"].encode("ascii"),
             ):
                 willexecutor["broadcast_status"] = _("Success")
@@ -194,26 +320,36 @@ 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")
             _logger.debug(url)
-            netname = "bitcoin"
-            if constants.net.NET_NAME != "mainnet":
-                netname = constants.net.NET_NAME
-            w = Willexecutors.send_request("get", url + "/" + netname + "/info")
-
-            willexecutor["url"] = url
-            willexecutor["status"] = w["status"]
-            willexecutor["base_fee"] = w["base_fee"]
-            willexecutor["address"] = w["address"]
-            if not willexecutor["info"]:
+            w = Willexecutors.send_request("get", url + "/" + chainname + "/info")
+            if isinstance(w, dict):
+                willexecutor["url"] = url
+                willexecutor["status"] = 200
+                willexecutor["base_fee"] = w["base_fee"]
+                willexecutor["address"] = w["address"]
                 willexecutor["info"] = w["info"]
-            _logger.debug(f"response_data {w['address']}")
+            _logger.debug(f"response_data {w}")
         except Exception as e:
             _logger.error(f"error {e} contacting {url}: {w}")
             willexecutor["status"] = "KO"
@@ -221,30 +357,60 @@ class Willexecutors:
         willexecutor["last_update"] = datetime.now().timestamp()
         return willexecutor
 
-    def initialize_willexecutor(willexecutor, url, status=None, selected=None):
-        willexecutor["url"] = url
-        if not status is None:
-            willexecutor["status"] = status
-        willexecutor["selected"] = Willexecutors.is_selected(willexecutor, selected)
+    def initialize_willexecutor(willexecutor, url, status=None, old_willexecutor={}):
+        """Initialize or merge executor configuration preserving user settings.
 
-    def download_list(bal_plugin):
+        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
+        else:
+            willexecutor["status"] = old_willexecutor.get("status",willexecutor.get("status","Ko"))
+        willexecutor["selected"]=Willexecutors.is_selected(old_willexecutor) or willexecutor.get("selected",False)
+        willexecutor["address"]=old_willexecutor.get("address",willexecutor.get("address",""))
+        willexecutor["promo_code"]=old_willexecutor.get("promo_code",willexecutor.get("promo_code"))
+
+
+
+    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:
-            l = Willexecutors.send_request(
-                "get", "https://welist.bitcoin-after.life/data/bitcoin?page=0&limit=100"
+            willexecutors = Willexecutors.send_request(
+                "get",
+                f"https://welist.bitcoin-after.life/data/{chainname}?page=0&limit=100",
             )
-            del l["status"]
-            for w in l:
-                willexecutor = l[w]
-                Willexecutors.initialize_willexecutor(willexecutor, w, "New", False)
+            # del willexecutors["status"]
+            for w in willexecutors:
+                if w not in ("status", "url"):
+                    Willexecutors.initialize_willexecutor(
+                        willexecutors[w], w, None, old_willexecutors.get(w,{})
+                    )
             # bal_plugin.WILLEXECUTORS.set(l)
             # bal_plugin.config.set_key(bal_plugin.WILLEXECUTORS,l,save=True)
-            return l
+            return willexecutors
 
         except Exception as e:
             _logger.error(f"Failed to download willexecutors list: {e}")
             return {}
 
-    def get_willexecutors_list_from_json(bal_plugin):
+    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)
@@ -252,13 +418,22 @@ class Willexecutors:
                     willexecutor = willexecutors[w]
                     Willexecutors.initialize_willexecutor(willexecutor, w, "New", False)
                 # bal_plugin.WILLEXECUTORS.set(willexecutors)
-                return h
+                return willexecutors
         except Exception as e:
             _logger.error(f"error opening willexecutors json: {e}")
 
             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(
@@ -269,14 +444,104 @@ class Willexecutors:
             _logger.error(f"error contacting {url} for checking txs {e}")
             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:
-    def __init__(self, url, base_fee, chain, info, version):
+    """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,
+        base_fee,
+        chain,
+        info,
+        version,
+        status,
+        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
         self.info = info
         self.version = version
+        self.status = status
+        self.promo_code = promo_code
+        self.is_selected = is_selected
+        self.id = self.compute_id()
 
     def from_dict(d):
-        we = WillExecutor(d["url"], d["base_fee"], d["chain"], d["info"], d["version"])
+        """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}"