docs(will): add module header

# Conflicts:
#	qt.py

README.md

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

bal.py

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

heirs.py

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

manifest.json

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

qt.py

@@ -1271,39 +1271,291 @@ class _LockTimeEditor:
         return cls.min_allowed_value <= x <= cls.max_allowed_value
 
 
-<<<<<<< HEAD
+class HeirsLockTimeEdit(QWidget, _LockTimeEditor):
-=======
+    valueEdited = pyqtSignal()
-    """
+    locktime_threshold = 50000000
-    BalWizardDialog - A custom QDialog that implements a multi-step wizard interface.
 
-    This dialog provides a structured, step-by-step workflow for complex operations
+    def __init__(self, parent=None, default_index=1):
-    in the Bal Electrum plugin, guiding users through a sequence of pages with
+        QWidget.__init__(self, parent)
-    forward/backward navigation and validation.
 
-    Features:
+        hbox = QHBoxLayout()
-    - Multi-page navigation with Previous/Next buttons
+        self.setLayout(hbox)
-    - Automatic validation before proceeding to next page
+        hbox.setContentsMargins(0, 0, 0, 0)
-    - Progress tracking with visual indicators
+        hbox.setSpacing(0)
-    - Customizable page flow and validation rules
-    - Integration with BalDialog base class for consistent styling
 
-    Usage:
+        self.locktime_raw_e = LockTimeRawEdit(self, time_edit=self)
-    The wizard follows a standard pattern:
+        self.locktime_date_e = LockTimeDateEdit(self, time_edit=self)
-    1. Initialize with a list of page constructors
+        self.editors = [self.locktime_raw_e, self.locktime_date_e]
-    2. Each page is responsible for its own setup and validation
-    3. The dialog manages navigation and state between pages
-    4. Finalize action is triggered when all pages are completed
 
-    Attributes:
+        self.combo = QComboBox()
-        pages (list): List of page constructors for the wizard
+        options = [_("Raw"), _("Date")]
-        current_page (int): Index of the currently displayed page
+        self.option_index_to_editor_map = {
-        page_widgets (list): List of instantiated page widgets
+            0: self.locktime_raw_e,
+            1: self.locktime_date_e,
+        }
+        self.combo.addItems(options)
+
+        self.editor = self.option_index_to_editor_map[default_index]
+        self.combo.currentIndexChanged.connect(self.on_current_index_changed)
+        self.combo.setCurrentIndex(default_index)
+        self.on_current_index_changed(default_index)
+
+        hbox.addWidget(self.combo)
+        for w in self.editors:
+            hbox.addWidget(w)
+        hbox.addStretch(1)
+        # spacer_widget = QWidget()
+        # spacer_widget.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        # hbox.addWidget(spacer_widget)
+
+        self.locktime_raw_e.editingFinished.connect(self.valueEdited.emit)
+        self.locktime_date_e.dateTimeChanged.connect(self.valueEdited.emit)
+        self.combo.currentIndexChanged.connect(self.valueEdited.emit)
+
+    def on_current_index_changed(self, i):
+        for w in self.editors:
+            w.setVisible(False)
+            w.setEnabled(False)
+        prev_locktime = self.editor.get_locktime()
+        self.editor = self.option_index_to_editor_map[i]
+        if self.editor.is_acceptable_locktime(prev_locktime):
+            self.editor.set_locktime(prev_locktime, force=True)
+        self.editor.setVisible(True)
+        self.editor.setEnabled(True)
+
+    def get_locktime(self) -> Optional[str]:
+        return self.editor.get_locktime()
+
+    def set_index(self, index):
+        self.combo.setCurrentIndex(index)
+        self.on_current_index_changed(index)
+
+    def set_locktime(self, x: Any, force=True) -> None:
+        self.editor.set_locktime(x, force)
+
+
+class LockTimeRawEdit(QLineEdit, _LockTimeEditor):
+    def __init__(self, parent=None, time_edit=None):
+        QLineEdit.__init__(self, parent)
+        self.setFixedWidth(14 * char_width_in_lineedit())
+        self.textChanged.connect(self.numbify)
+        self.isdays = False
+        self.isyears = False
+        self.isblocks = False
+        self.time_edit = time_edit
+
+    def replace_str(self, text):
+        return str(text).replace("d", "").replace("y", "").replace("b", "")
+
+    def checkbdy(self, s, pos, appendix):
+        try:
+            charpos = pos - 1
+            charpos = max(0, charpos)
+            charpos = min(len(s) - 1, charpos)
+            if appendix == s[charpos]:
+                s = self.replace_str(s) + appendix
+                pos = charpos
+        except Exception:
+            pass
+        return pos, s
+
+    def numbify(self):
+        text = self.text().strip()
+        # chars = '0123456789bdy' removed the option to choose locktime by block
+        chars = "0123456789dy"
+        pos = self.cursorPosition()
+        pos = len("".join([i for i in text[:pos] if i in chars]))
+        s = "".join([i for i in text if i in chars])
+        self.isdays = False
+        self.isyears = False
+        self.isblocks = False
+
+        pos, s = self.checkbdy(s, pos, "d")
+        pos, s = self.checkbdy(s, pos, "y")
+        pos, s = self.checkbdy(s, pos, "b")
+
+        if "d" in s:
+            self.isdays = True
+        if "y" in s:
+            self.isyears = True
+        if "b" in s:
+            self.isblocks = True
+
+        if self.isdays:
+            s = self.replace_str(s) + "d"
+        if self.isyears:
+            s = self.replace_str(s) + "y"
+        if self.isblocks:
+            s = self.replace_str(s) + "b"
+
+        self.set_locktime(s, force=False)
+        # setText sets Modified to False.  Instead we want to remember
+        # if updates were because of user modification.
+        self.setModified(self.hasFocus())
+        self.setCursorPosition(pos)
+
+    def get_locktime(self) -> Optional[str]:
+        try:
+            return str(self.text())
+        except Exception:
+            return None
+
+    def set_locktime(self, x: Any, force=True) -> None:
+        out = str(x)
+        if "d" in out:
+            out = self.replace_str(x) + "d"
+        elif "y" in out:
+            out = self.replace_str(x) + "y"
+        elif "b" in out:
+            out = self.replace_str(x) + "b"
+        else:
+            try:
+                out = int(x)
+            except Exception:
+                self.setText("")
+                return
+            out = max(out, self.min_allowed_value)
+            out = min(out, self.max_allowed_value)
+        self.setText(str(out))
+
+
+class LockTimeHeightEdit(LockTimeRawEdit):
+    max_allowed_value = NLOCKTIME_BLOCKHEIGHT_MAX
+
+    def __init__(self, parent=None, time_edit=None):
+        LockTimeRawEdit.__init__(self, parent)
+        self.setFixedWidth(20 * char_width_in_lineedit())
+        self.time_edit = time_edit
+
+    def paintEvent(self, event):
+        super().paintEvent(event)
+        panel = QStyleOptionFrame()
+        self.initStyleOption(panel)
+        textRect = self.style().subElementRect(QStyle.SE_LineEditContents, panel, self)
+        textRect.adjust(2, 0, -10, 0)
+        painter = QPainter(self)
+        painter.setPen(ColorScheme.GRAY.as_color())
+        painter.drawText(textRect, int(Qt.AlignRight | Qt.AlignVCenter), "height")
+
+
+def get_max_allowed_timestamp() -> int:
+    ts = NLOCKTIME_MAX
+    # Test if this value is within the valid timestamp limits (which is platform-dependent).
+    # see #6170
+    try:
+        datetime.fromtimestamp(ts)
+    except (OSError, OverflowError):
+        ts = 2**31 - 1  # INT32_MAX
+        datetime.fromtimestamp(ts)  # test if raises
+    return ts
+
+
+class LockTimeDateEdit(QDateTimeEdit, _LockTimeEditor):
+    min_allowed_value = NLOCKTIME_BLOCKHEIGHT_MAX + 1
+    max_allowed_value = get_max_allowed_timestamp()
+
+    def __init__(self, parent=None, time_edit=None):
+        QDateTimeEdit.__init__(self, parent)
+        self.setMinimumDateTime(datetime.fromtimestamp(self.min_allowed_value))
+        self.setMaximumDateTime(datetime.fromtimestamp(self.max_allowed_value))
+        self.setDateTime(QDateTime.currentDateTime())
+        self.time_edit = time_edit
+
+    def get_locktime(self) -> Optional[int]:
+        dt = self.dateTime().toPyDateTime()
+        locktime = int(time.mktime(dt.timetuple()))
+        return locktime
+
+    def set_locktime(self, x: Any, force=False) -> None:
+        if not self.is_acceptable_locktime(x):
+            self.setDateTime(QDateTime.currentDateTime())
+            return
+        try:
+            x = int(x)
+        except Exception:
+            self.setDateTime(QDateTime.currentDateTime())
+            return
+        dt = datetime.fromtimestamp(x)
+        self.setDateTime(dt)
+
+
+_NOT_GIVEN = object()  # sentinel value
+
+
+class PercAmountEdit(BTCAmountEdit):
+    def __init__(
+        self, decimal_point, is_int=False, parent=None, *, max_amount=_NOT_GIVEN
+    ):
+        super().__init__(decimal_point, is_int, parent, max_amount=max_amount)
+
+    def numbify(self):
+        text = self.text().strip()
+        if text == "!":
+            self.shortcut.emit()
+            return
+        pos = self.cursorPosition()
+        chars = "0123456789%"
+        chars += DECIMAL_POINT
+
+        s = "".join([i for i in text if i in chars])
+
+        if "%" in s:
+            self.is_perc = True
+            s = s.replace("%", "")
+        else:
+            self.is_perc = False
+
+        if DECIMAL_POINT in s:
+            p = s.find(DECIMAL_POINT)
+            s = s.replace(DECIMAL_POINT, "")
+            s = s[:p] + DECIMAL_POINT + s[p : p + 8]
+        if self.is_perc:
+            s += "%"
+
+        self.setText(s)
+        self.setModified(self.hasFocus())
+        self.setCursorPosition(pos)
+
+    def _get_amount_from_text(self, text: str) -> Union[None, Decimal, int]:
+        try:
+            text = text.replace(DECIMAL_POINT, ".")
+            text = text.replace("%", "")
+            return (Decimal)(text)
+        except Exception:
+            return None
+
+    def _get_text_from_amount(self, amount):
+        out = super()._get_text_from_amount(amount)
+        if self.is_perc:
+            out += "%"
+        return out
+
+    def paintEvent(self, event):
+        QLineEdit.paintEvent(self, event)
+        if self.base_unit:
+            panel = QStyleOptionFrame()
+            self.initStyleOption(panel)
+            textRect = self.style().subElementRect(
+                QStyle.SubElement.SE_LineEditContents, panel, self
+            )
+            textRect.adjust(2, 0, -10, 0)
+            painter = QPainter(self)
+            painter.setPen(ColorScheme.GRAY.as_color())
+            if len(self.text()) == 0:
+                painter.drawText(
+                    textRect,
+                    int(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter),
+                    self.base_unit() + " or perc value",
+                )
+
+
+class BalDialog(WindowModalDialog):
+    def __init__(self, parent, bal_plugin, title=None, icon="icons/bal32x32.png"):
+        self.parent = parent
+        WindowModalDialog.__init__(self, parent, title)
+        # WindowModalDialog.__init__(self,parent)
+        self.setWindowIcon(read_QIcon_from_bytes(bal_plugin.read_file(icon)))
 
-    Args:
-        parent: Optional parent QWidget
-        title (str): Title to display in the dialog header
-        pages (list): List of page constructors (callables) for each step
-    """
 
 class BalWizardDialog(BalDialog):
     def __init__(self, bal_window: "BalWindow"):
@@ -1763,6 +2015,7 @@ class BalWaitingDialog(BalDialog):
         self.thread.stop()
 
     def update_message(self, msg):
+        print(msg)
         self.message_label.setText(msg)
 
     def update(self, msg):
@@ -1817,21 +2070,6 @@ class BalBuildWillDialog(BalDialog):
     COLOR_OK = "#05ad05"
 
     def __init__(self, bal_window, parent=None):
-<<<<<<< HEAD
-=======
-        """Initialize the Build Will dialog.
-
-        Args:
-            bal_window (BalWindow): The main application window
-            parent (QWidget, optional): Parent widget. Defaults to None.
-
-        Initializes:
-            - Main UI components (message label, container widget)
-            - Message queue system with debounce timer
-            - Layout management
-            - Network connection
-        """
->>>>>>> origin/doc
         if not parent:
             parent = bal_window.window
         BalDialog.__init__(self, parent, bal_window.bal_plugin, _("Building Will"))
@@ -1839,7 +2077,6 @@ class BalBuildWillDialog(BalDialog):
         self.updatemessage.connect(self.msg_update)
         self.bal_window = bal_window
         self.bal_plugin = bal_window.bal_plugin
-<<<<<<< HEAD
         self.message_label = QLabel(_("Building Will:"))
         self.vbox = QVBoxLayout(self)
         self.vbox.addWidget(self.message_label,0)
@@ -1850,45 +2087,6 @@ class BalBuildWillDialog(BalDialog):
         self.setMinimumHeight(100)
         self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
         self.labels = []
-=======
-
-        # Main message label
-        self.message_label = QLabel(_("Building Will:"))
-        self.vbox = QVBoxLayout(self)
-        self.vbox.addWidget(self.message_label, 0)
-
-        # Container for dynamic messages
-        self.qwidget = QWidget(self)
-        self.vbox.addWidget(self.qwidget, 1)
-
-        # Layout for messages with reduced spacing
-        self.labelsbox = QVBoxLayout(self.qwidget)
-        self.labelsbox.setContentsMargins(0, 0, 0, 0)
-        self.labelsbox.setSpacing(4)  # Reduced spacing between messages
-
-        # Set minimum dimensions
-        self.setMinimumWidth(600)
-        self.setMinimumHeight(100)
-        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
-
-        # Message queue implementation for efficient updates
-        self._message_queue = []  # Thread-safe message queue
-        self._message_timer = QTimer(self)
-        self._message_timer.setSingleShot(True)
-        self._message_timer.setInterval(50)  # Debounce interval: 50ms
-        self._message_timer.timeout.connect(self._process_message_queue)
-
-        # Other initialization
-        self.labels = []  # Immediate message storage
-        self.check_row = None
-        self.inval_row = None
-        self.build_row = None
-        self.sign_row = None
-        self.push_row = None
-        self.network = Network.get_instance()
-        self._stopping = False
-
->>>>>>> origin/doc
         self.check_row = None
         self.inval_row = None
         self.build_row = None
@@ -2337,84 +2535,28 @@ class BalBuildWillDialog(BalDialog):
                 w.setParent(None)
                 w.deleteLater()
 
+    #def msg_update(self):
+    #    self.clear_layout(self.labelsbox)
+    #    for label in self.labels:
+    #        label=label.replace("\n","<br>")
+    #        qlabel=QLabel(label)
+    #        qlabel.setWordWrap(True)
+    #        self.labelsbox.addWidget(qlabel)
+
+    #    self.labelsbox.activate()
+    #    self.qwidget.setMinimumSize(self.labelsbox.sizeHint())
+    #    self.qwidget.adjustSize()
+    #    from PyQt6.QtWidgets import QApplication
+    #    QApplication.processEvents()
+    #    
+    #    self.adjustSize()
     def msg_update(self):
-<<<<<<< HEAD
+        full_text = "<br><br>".join(self.labels).replace("\n", "<br>")
-        self.clear_layout(self.labelsbox)
+        self.message_label.setText(full_text)
-        for label in self.labels:
+        self.message_label.adjustSize()
-            label=label.replace("\n","<br>")
+        #self.setMinimumHeight(len(self.labels)*40)
-            qlabel=QLabel(label)
+        self.resize(self.sizeHint())
-            self.labelsbox.addWidget(QLabel(label),1)
-        self.setMinimumHeight(30*(len(self.labels)+2))
         
-=======
-        """Updates the UI with new messages using a debounced queue system.
-
-        This method implements the following logic:
-        1. Adds all pending messages to the queue
-        2. Clears the immediate message storage
-        3. Starts the debounce timer if not already active
-
-        The actual UI update happens in _process_message_queue after the
-        debounce interval to prevent excessive UI updates.
-
-        Note:
-            Thread-safe operation - can be called from any thread
-        """
-        self._message_queue.extend(self.labels)
-        self.labels = []  # Clear immediate labels after queuing
-        if not self._message_timer.isActive():
-            self._message_timer.start()
-
-    def _process_message_queue(self):
-        """Processes queued messages with debounce for efficient UI updates.
-
-        This method:
-        1. Clears the existing layout
-        2. Processes all queued messages
-        3. Updates the UI once with all new messages
-        4. Resets the queue
-        5. Adjusts dialog height based on content
-
-        The debounce interval (50ms) ensures rapid message bursts are
-        processed in a single batch, reducing UI flicker.
-
-        Note:
-            Called automatically by QTimer after debounce interval
-        """
-        if not self._message_queue:
-            return
-
-        # Clear existing layout
-        self.clear_layout(self.labelsbox)
-
-        # Process all queued messages
-        for text in self._message_queue:
-            try:
-                # Format text for rich display
-                formatted_text = text.replace("\n", "<br>")
-
-                # Create label with proper settings
-                label = QLabel(formatted_text)
-                label.setWordWrap(True)
-                label.setTextFormat(Qt.TextFormat.RichText)
-                label.setOpenExternalLinks(False)  # Security
-
-                # Set size policy
-                label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
-
-                # Add to layout
-                self.labelsbox.addWidget(label)
-
-            except Exception as e:
-                # Log errors without interrupting processing
-                import logging
-                logging.error(f"Error creating label in BalBuildWillDialog: {e}")
-
-        # Reset queue and update dimensions
-        self._message_queue = []
-        self.setMinimumHeight(min(30 * (len(self.labels) + 2), 400))  # Max height limit
-
->>>>>>> origin/doc
 
     def get_text(self):
         return self.message_label.text()
@@ -3632,23 +3774,4 @@ class CheckAliveException(Exception):
     def __init__(self,timestamp_to_check):
             self.timestamp_to_check = timestamp_to_check
     def __str__(self):
-<<<<<<< HEAD
-=======
-
-    def __del__(self):
-        """Explicit cleanup to prevent memory leaks.
-
-        This destructor ensures proper cleanup of:
-        - Message queue timer
-        - All widgets in the layout
-        - Network connections
-
-        Called automatically when the dialog is destroyed.
-        """
-        if hasattr(self, '_message_timer') and self._message_timer:
-            self._message_timer.stop()
-            self._message_timer.deleteLater()
-        self.clear_layout(self.labelsbox)
-
->>>>>>> origin/doc
         return "Check alive expired please update it: {}".format(datetime.fromtimestamp(self.timestamp_to_check).isoformat())

util.py

@@ -1,3 +1,7 @@
+# -*- coding: utf-8 -*-
+
+# Utility module for the BAL Electrum plugin.
+
 import bisect
 from datetime import datetime, timedelta
 
@@ -10,7 +14,26 @@ 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:
@@ -22,6 +45,20 @@ class Util:
         return str(locktime)
 
     def str_to_locktime(locktime):
+        """Convert a string representation to a locktime value.
+
+        If the string ends with a suffix ('y', 'd', 'b'), it is preserved as-is
+        for later parsing. Numeric strings are converted to integers. ISO 8601
+        date strings are converted to Unix timestamps.
+
+        Args:
+            locktime (str): A locktime string, number, ISO date, or
+                suffixed interval ('y' for years, 'd' for days, 'b' for blocks).
+
+        Returns:
+            int or str: An integer locktime value, or the original string if it
+                carries a suffix for deferred parsing.
+        """
         try:
             if locktime[-1] in ("y", "d", "b"):
                 return locktime
@@ -34,6 +71,23 @@ class Util:
         return int(timestamp)
 
     def parse_locktime_string(locktime, w=None):
+        """Parse a locktime string into an integer locktime value.
+
+        Supports multiple formats:
+        - Plain integer: returned directly.
+        - Suffix 'y': converted to days (N * 365) then to a timestamp at midnight.
+        - Suffix 'd': converted to a timestamp N days from now at midnight.
+        - Suffix 'b': added to the current block height (requires wallet network).
+
+        Args:
+            locktime (str): The locktime string to parse.
+            w (optional): The Electrum wallet, used to resolve block-height-based
+                locktimes. Defaults to None.
+
+        Returns:
+            int: The resolved locktime as an integer (timestamp or block height),
+                or 0 if parsing fails.
+        """
         try:
             return int(locktime)
 
@@ -61,6 +115,21 @@ class Util:
         return 0
 
     def int_locktime(seconds=0, minutes=0, hours=0, days=0, blocks=0):
+        """Convert time intervals into a locktime integer value in seconds.
+
+        Each unit is converted to seconds and summed. Block intervals are
+        estimated at 600 seconds (10 minutes) per block.
+
+        Args:
+            seconds (int): Number of seconds. Defaults to 0.
+            minutes (int): Number of minutes. Defaults to 0.
+            hours (int): Number of hours. Defaults to 0.
+            days (int): Number of days. Defaults to 0.
+            blocks (int): Number of blocks (600 seconds each). Defaults to 0.
+
+        Returns:
+            int: Total time in seconds.
+        """
         return int(
             seconds
             + minutes * 60
@@ -70,6 +139,20 @@ 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:
@@ -79,6 +162,20 @@ class Util:
                 return 0
 
     def decode_amount(amount, decimal_point):
+        """Decode an integer amount to a human-readable string.
+
+        If the amount is a percentage (ends with '%'), it is returned as-is.
+        Otherwise, the integer value is divided by 10^decimal_point and formatted
+        to the specified number of decimal places.
+
+        Args:
+            amount: The amount to decode, either an integer or a percentage string.
+            decimal_point (int): The number of decimal places for formatting.
+
+        Returns:
+            str: The decoded amount string formatted to decimal_point places,
+                the original percentage string, or a string representation on error.
+        """
         if Util.is_perc(amount):
             return amount
         else:
@@ -89,12 +186,30 @@ class Util:
                 return str(amount)
 
     def is_perc(value):
+        """Check whether a value represents a percentage.
+
+        Args:
+            value: The value to check.
+
+        Returns:
+            bool: True if the value ends with '%', False otherwise or on error.
+        """
         try:
             return value[-1] == "%"
         except Exception:
             return False
 
     def cmp_array(heira, heirb):
+        """Compare two heir arrays element by element.
+
+        Args:
+            heira (list): First heir array.
+            heirb (list): Second heir array.
+
+        Returns:
+            bool: True if both arrays have the same length and identical elements,
+                False otherwise.
+        """
         try:
             if len(heira) != len(heirb):
                 return False
@@ -106,11 +221,32 @@ class Util:
             return False
 
     def cmp_heir(heira, heirb):
+        """Compare two heirs by their address and amount.
+
+        Args:
+            heira: First heir (index 0=address, index 1=amount).
+            heirb: Second heir (same format).
+
+        Returns:
+            bool: True if both heirs have the same address and amount.
+        """
         if heira[0] == heirb[0] and heira[1] == heirb[1]:
             return True
         return False
 
     def cmp_willexecutor(willexecutora, willexecutorb):
+        """Compare two will executors for equality.
+
+        Two executors are considered equal if they are the same object, or if they
+        share the same url, address, and base_fee.
+
+        Args:
+            willexecutora (dict): First will executor dictionary.
+            willexecutorb (dict): Second will executor dictionary.
+
+        Returns:
+            bool: True if the executors are equal, False otherwise.
+        """
         if willexecutora == willexecutorb:
             return True
         try:
@@ -125,6 +261,19 @@ class Util:
         return False
 
     def search_heir_by_values(heirs, heir, values):
+        """Search for an heir in a dict by matching specific field values.
+
+        Iterates over all heirs and returns the key of the first heir whose
+        values for all specified fields match those of the given heir.
+
+        Args:
+            heirs (dict): Dictionary of heirs keyed by ID.
+            heir (dict): The reference heir to match against.
+            values (list): List of field keys to compare.
+
+        Returns:
+            str or bool: The key of the first matching heir, or False if no match.
+        """
         for h, v in heirs.items():
             found = False
             for val in values:
@@ -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,6 +303,24 @@ class Util:
     def cmp_heirs_by_values(
         heirsa, heirsb, values, exclude_willexecutors=False, reverse=True
     ):
+        """Compare two heir dictionaries by specific field values.
+
+        Performs a bidirectional comparison: every heir in heirsa must have a
+        matching heir in heirsb (and vice versa when reverse=True) for the
+        specified field values.
+
+        Args:
+            heirsa (dict): First dictionary of heirs.
+            heirsb (dict): Second dictionary of heirs.
+            values (list): Field keys to compare.
+            exclude_willexecutors (bool): If True, exclude will-executor entries
+                (containing 'w!ll3x3c"') from comparison. Defaults to False.
+            reverse (bool): If True, also verify the reverse comparison. Defaults
+                to True.
+
+        Returns:
+            bool: True if all matching heirs are found in both directions.
+        """
         for heira in heirsa:
             if (
                 exclude_willexecutors and 'w!ll3x3c"' not in heira
@@ -171,6 +348,26 @@ class Util:
         cmp_function=lambda x, y: x[0] == y[0] and x[3] == y[3],
         reverse=True,
     ):
+        """Compare two heir dictionaries using a custom comparison function.
+
+        Performs a bidirectional comparison. Will-executor entries are excluded
+        from the comparison. If an exact key match fails, a fallback search by
+        values (indices 0 and 3) is attempted.
+
+        Args:
+            heirsa (dict): First dictionary of heirs.
+            heirsb (dict): Second dictionary of heirs.
+            cmp_function (callable): A function taking two heir values and returning
+                a bool. Defaults to comparing index 0 (address) and index 3.
+            reverse (bool): If True, also verify the reverse comparison. Defaults
+                to True.
+
+        Returns:
+            bool: True if all heirs match in both directions.
+
+        Raises:
+            Exception: Re-raises any exception encountered during comparison.
+        """
         try:
             for heir in heirsa:
                 if 'w!ll3x3c"' not in heir:
@@ -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,6 +443,20 @@ class Util:
         return True
 
     def get_value_amount(txa, txb):
+        """Calculate the total value of outputs that appear in both transactions.
+
+        For each output in txa, checks if a matching output (same amount and/or
+        same address) exists in txb. Returns the sum of matched output values,
+        or False if any output has neither a matching amount nor address.
+
+        Args:
+            txa: Reference transaction (whose outputs are evaluated).
+            txb: Comparison transaction.
+
+        Returns:
+            int or False: Total satoshi value of matched outputs, or False if
+                any output has no correspondence at all.
+        """
         outputsa = txa.outputs()
         # outputsb = txb.outputs()
         value_amount = 0
@@ -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,6 +538,18 @@ class Util:
         return out
 
     def cmp_locktime(locktimea, locktimeb):
+        """Compare two locktime values.
+
+        If the locktimes are equal, returns 0. If both are suffixed strings
+        with the same unit suffix, compares their numeric parts.
+
+        Args:
+            locktimea: First locktime value.
+            locktimeb: Second locktime value.
+
+        Returns:
+            int: Negative if locktimea < locktimeb, 0 if equal, positive if greater.
+        """
         if locktimea == locktimeb:
             return 0
         strlocktimea = str(locktimea)
@@ -269,17 +563,48 @@ class Util:
                 return int(locktimea) - (locktimeb)
 
     def get_lowest_valid_tx(available_utxos, will):
+        """Find the lowest valid transaction in a will by locktime.
+
+        Iterates through will items sorted by locktime to find the first
+        transaction whose inputs are still available.
+
+        Args:
+            available_utxos: List of available UTXOs.
+            will (dict): Dictionary of will items keyed by transaction ID.
+
+        Note:
+            This method is incomplete and currently does not return a value.
+        """
         will = sorted(will.items(), key=lambda x: x[1]["tx"].locktime)
         for txid, willitem in will.items():
             pass
 
     def get_locktimes(will):
+        """Extract all unique locktime values from a will.
+
+        Args:
+            will (dict): Dictionary of will items keyed by transaction ID.
+
+        Returns:
+            dict_keys: Collection of unique locktime values from the will.
+        """
         locktimes = {}
         for txid, willitem in will.items():
             locktimes[willitem["tx"].locktime] = True
         return locktimes.keys()
 
     def get_lowest_locktimes(locktimes):
+        """Separate and sort locktimes into timestamp and block-height groups.
+
+        Locktimes below LOCKTIME_THRESHOLD are sorted as block heights;
+        those above are sorted as timestamps.
+
+        Args:
+            locktimes: Iterable of locktime values.
+
+        Returns:
+            tuple: (sorted_timestamp_list, sorted_block_list)
+        """
         sorted_timestamp = []
         sorted_block = []
         for locktime in locktimes:
@@ -292,18 +617,57 @@ class Util:
         return sorted(sorted_timestamp), sorted(sorted_block)
 
     def get_lowest_locktimes_from_will(will):
+        """Get the lowest locktimes from a will, separated by type.
+
+        Convenience method that combines get_locktimes and get_lowest_locktimes.
+
+        Args:
+            will (dict): Dictionary of will items keyed by transaction ID.
+
+        Returns:
+            tuple: (sorted_timestamp_list, sorted_block_list)
+        """
         return Util.get_lowest_locktimes(Util.get_locktimes(will))
 
     def search_willtx_per_io(will, tx):
+        """Search for a will transaction matching a given transaction by inputs and outputs.
+
+        Args:
+            will (dict): Dictionary of will items keyed by transaction ID.
+            tx (dict): Transaction dictionary with a 'tx' key containing the
+                transaction to match.
+
+        Returns:
+            tuple: (will_id, will_item) if found, (None, None) otherwise.
+        """
         for wid, w in will.items():
             if Util.cmp_txs(w["tx"], tx["tx"]):
                 return wid, w
         return None, None
 
     def invalidate_will(will):
+        """Invalidate a will.
+
+        Note:
+            Not yet implemented.
+
+        Args:
+            will (dict): Dictionary of will items to invalidate.
+
+        Raises:
+            Exception: Always raises "not implemented".
+        """
         raise Exception("not implemented")
 
     def get_will_spent_utxos(will):
+        """Collect all UTXOs spent by the transactions in a will.
+
+        Args:
+            will (dict): Dictionary of will items keyed by transaction ID.
+
+        Returns:
+            list: All input UTXOs from all transactions in the will.
+        """
         utxos = []
         for txid, willitem in will.items():
             utxos += willitem["tx"].inputs()
@@ -311,6 +675,17 @@ 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:
@@ -322,6 +697,15 @@ class Util:
         return str(utxo)
 
     def cmp_utxo(utxoa, utxob):
+        """Compare two UTXOs for equality based on their string representation.
+
+        Args:
+            utxoa: First UTXO object.
+            utxob: Second UTXO object.
+
+        Returns:
+            bool: True if both UTXOs have the same string representation.
+        """
         utxoa = Util.utxo_to_str(utxoa)
         utxob = Util.utxo_to_str(utxob)
         if utxoa == utxob:
@@ -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()
@@ -381,6 +833,18 @@ class Util:
             return out
 
     def get_current_height(network):
+        """Get the current best block height from the Electrum network.
+
+        Uses the minimum of the SPV-verified chain height and the server-reported
+        height to discourage fee sniping. Returns 0 if the network is unavailable,
+        stale, or suspiciously divergent.
+
+        Args:
+            network: The Electrum network object.
+
+        Returns:
+            int: The current block height, or 0 if unavailable/unreliable.
+        """
         # if no network or not up to date, just set locktime to zero
         if not network:
             return 0
@@ -402,6 +866,16 @@ class Util:
         return height
 
     def print_var(var, name="", veryverbose=False):
+        """Print detailed debug information about a variable.
+
+        Attempts to print various representations: str, repr, dict, dir, type,
+        to_json, and __slotnames__.
+
+        Args:
+            var: The variable to inspect.
+            name (str): A label for the output header. Defaults to "".
+            veryverbose (bool): Unused parameter. Defaults to False.
+        """
         print(f"---{name}---")
         if var is not None:
             try:
@@ -436,6 +910,15 @@ class Util:
         print(f"---end {name}---")
 
     def print_utxo(utxo, name=""):
+        """Print detailed debug information about a UTXO.
+
+        Prints the UTXO itself, its prevout, script_sig, witness, and private
+        attributes (address, scriptpubkey, value_sats).
+
+        Args:
+            utxo: The UTXO object to inspect.
+            name (str): A label for the output header. Defaults to "".
+        """
         print(f"---utxo-{name}---")
         Util.print_var(utxo, name)
         Util.print_prevout(utxo.prevout, name)
@@ -447,12 +930,29 @@ class Util:
         print(f"---utxo-end {name}---")
 
     def print_prevout(prevout, name=""):
+        """Print detailed debug information about a prevout object.
+
+        Args:
+            prevout: The prevout object to inspect.
+            name (str): A label for the output header. Defaults to "".
+        """
         print(f"---prevout-{name}---")
         Util.print_var(prevout, f"{name}-prevout")
         Util.print_var(prevout._asdict())
         print(f"---prevout-end {name}---")
 
     def export_meta_gui(electrum_window, title, exporter):
+        """Export data to a file via the Electrum GUI save dialog.
+
+        Opens a file save dialog, calls the exporter function with the chosen
+        filename, and shows a success or error message.
+
+        Args:
+            electrum_window: The Electrum main window object.
+            title (str): Description of the data being exported.
+            exporter (callable): A function that takes a filename and writes the
+                data to it. Raises FileExportFailed on error.
+        """
         filter_ = "All files (*)"
         filename = getSaveFileName(
             parent=electrum_window,
@@ -473,10 +973,27 @@ class Util:
             )
 
     def copy(dicto, dictfrom):
+        """Copy all key-value pairs from one dictionary to another.
+
+        Args:
+            dicto (dict): The destination dictionary.
+            dictfrom (dict): The source dictionary.
+        """
         for k, v in dictfrom.items():
             dicto[k] = v
 
     def fix_will_settings_tx_fees(will_settings):
+        """Migrate will settings from old 'tx_fees' key to 'baltx_fees'.
+
+        Renames the 'tx_fees' key to 'baltx_fees' in the will settings dictionary
+        for backward compatibility.
+
+        Args:
+            will_settings (dict): The will settings dictionary to update.
+
+        Returns:
+            bool: True if the key was renamed, False if no migration was needed.
+        """
         tx_fees = will_settings.get("tx_fees", False)
         have_to_update = False
         if tx_fees:
@@ -486,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)
@@ -494,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"

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

willexecutors.py

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