SAFE21.io/bal-electrum-plugin
1
0
Fork 0
forked from bitcoinafterlife/bal-electrum-plugin
Code Pull Requests Activity

feat(bal): Group A (timestamps + statuses + anticipate docs) and Group B (auto-sign) v0.3.4

Browse Source 
Bump plugin version to 0.3.4 (manifest, __init__, plugin_base, VERSION).

GROUP A
- A1: remove block-height locktimes; the plugin now uses UNIX timestamps
  only. The NLOCKTIME_BLOCKHEIGHT_MAX guard is kept on purpose (it forces
  every locktime to be a timestamp). chk_locktime is now 2-arg; int_locktime
  and anticipate_locktime no longer accept blocks; RAW input only accepts d/y.
  Two now-dormant configs (LOCKTIME_BLOCKS, LOCKTIMEDELTA_BLOCKS) are kept with
  comments to avoid touching persisted keys.
- A2: rename PENDING -> MEMPOOL everywhere (label 'Mempool', yellow #ffce30);
  add new UPDATED status; ANTICIPATED & UPDATED keep VALID; documented
  set_status rules; backward-compat migration (old PENDING -> MEMPOOL).
- A3: clarify that anticipating to a future date only rebuilds (never
  invalidates), while only a past locktime invalidates (WillExpired). Code was
  already correct; only the comment and docs were fixed.

Colour follow-up: UPDATED lightened from #800080 to #b266b2 (more readable),
updated in theme.py, docs and the theme test.

GROUP B
- B1: verified the 'Create your will' button already opens the guided wizard
  (no code change needed).
- B2: new persisted AUTO_SIGN setting (default ON) with an 'Auto-sign on Check'
  checkbox in the settings dialog. When enabled, Check signs and broadcasts
  automatically; the wallet password is requested only for encrypted wallets.

B2 follow-up (fixes reported after testing):
- Remove the duplicate sign/broadcast cycle in lists.check(); build_will_task()
  already signs and broadcasts.
- Suppress the manual 'press Sign/Broadcast' hint and its popup when AUTO_SIGN
  is ON (kept when OFF).
- Make broadcast one-shot: removed the retry flag and the Exception('retry');
  failed will-executors stay PUSH_FAIL and are skipped (no endless retry).
  PUSHED transactions are already excluded from re-collection.

Docs: inheritance-options.md/.html and inheritance-flow.svg updated to v0.3.4.
Tests: 206 passing (new test_anticipate_manual_locktime, test_anticipate_past_locktime,
test_group_b_auto_sign; updated core/util, core/will_extra, gui/theme, gui/widgets).
CHANGELOG.md added with one numbered entry per task.
This commit is contained in:
donkey-ai
2026-06-28 23:00:23 -04:00
parent 10d0b85779
commit dc166d04ff
23 changed files with 1374 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
bal/VERSION
View File

@@ -1 +1 @@
0.3.3
0.3.4

2
bal/__init__.py
View File

@@ -34,4 +34,4 @@ The plugin targets Electrum 4.7.2 (the last stable release exposing
``json_db.register_dict``) and PyQt6.
"""
__version__ = "0.3.3"
__version__ = "0.3.4"

19
bal/core/plugin_base.py
View File

@@ -91,7 +91,7 @@ class BalPlugin(BasePlugin):
"""
_version = None
__version__ = "0.3.3" # AUTOMATICALLY GENERATED DO NOT EDIT
__version__ = "0.3.4" # AUTOMATICALLY GENERATED DO NOT EDIT
# Command used to open an .ics calendar file, per operating system.
default_app = {
@@ -146,8 +146,17 @@ class BalPlugin(BasePlugin):
self.ASK_BROADCAST = BalConfig(config, "bal_ask_broadcast", True)
self.BROADCAST = BalConfig(config, "bal_broadcast", True)
self.LOCKTIME_TIME = BalConfig(config, "bal_locktime_time", 90)
# NOTE (A1): block-height locktimes were removed; the plugin now uses
# only timestamp-based locktimes. LOCKTIME_BLOCKS is therefore no longer
# read anywhere in the code. It is kept here (dormant) on purpose, to
# avoid touching a persisted config key ("bal_locktime_blocks") that may
# already exist in some users' saved settings.
self.LOCKTIME_BLOCKS = BalConfig(config, "bal_locktime_blocks", 144 * 90)
self.LOCKTIMEDELTA_TIME = BalConfig(config, "bal_locktimedelta_time", 7)
# NOTE (A1): same as LOCKTIME_BLOCKS above - block-height locktimes were
# removed, so LOCKTIMEDELTA_BLOCKS is no longer read anywhere. It is kept
# here (dormant) on purpose, to avoid touching the persisted config key
# "bal_locktimedelta_blocks" that may already exist in saved settings.
self.LOCKTIMEDELTA_BLOCKS = BalConfig(
config, "bal_locktimedelta_blocks", 144 * 7
)
@@ -158,6 +167,14 @@ class BalPlugin(BasePlugin):
self.PREVIEW = BalConfig(config, "bal_preview", True)
self.SAVE_TXS = BalConfig(config, "bal_save_txs", True)
# AUTO_SIGN (Group B / B2): when enabled, pressing "Check" will, after
# querying the will-executor servers, automatically sign the will
# transactions and broadcast them to their will-executors, without the
# user having to invoke "Sign" and "Broadcast" separately. The wallet
# password is requested only when the wallet is actually encrypted
# (handled by BalWindow.get_wallet_password). Default ON.
self.AUTO_SIGN = BalConfig(config, "bal_auto_sign", 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)

92
bal/core/util.py
View File

@@ -24,7 +24,13 @@ from electrum.transaction import PartialTxOutput
# Bitcoin consensus rule: an nLockTime value strictly below this threshold is
# interpreted as a *block height*, otherwise it is interpreted as a *UNIX
# timestamp*. This single constant drives most of the locktime handling below.
# timestamp*.
#
# The plugin now uses ONLY timestamp-based locktimes (block-height locktimes
# were removed so that every locktime can be compared and ordered consistently).
# This constant is kept as a guard: it is the boundary that lets us reject any
# value that would fall in the block-height range and force every locktime to be
# a timestamp.
LOCKTIME_THRESHOLD = 500000000
@@ -56,11 +62,16 @@ class Util:
def str_to_locktime(locktime):
"""Parse a user-entered locktime string into its stored form.
Relative values keep their suffix (``"30d"``, ``"1y"``, ``"144b"``);
absolute ISO dates are converted to an integer UNIX timestamp.
Relative values keep their suffix (``"30d"``, ``"1y"``); absolute ISO
dates are converted to an integer UNIX timestamp.
Note: only timestamp-based locktimes are supported. The legacy
block-height suffix ``"b"`` has been removed on purpose, so that every
locktime in the plugin is a UNIX timestamp and can always be compared
and ordered consistently.
"""
try:
if locktime[-1] in ("y", "d", "b"):
if locktime[-1] in ("y", "d"):
return locktime
else:
return int(locktime)
@@ -78,8 +89,12 @@ class Util:
* plain int / timestamp -> returned unchanged
* ``"<n>y"`` -> n years from now (as a timestamp)
* ``"<n>d"`` -> n days from now (as a timestamp)
* ``"<n>b"`` -> current block height + n (needs wallet
``w`` to read the chain height)
Note: the legacy block-height form ``"<n>b"`` has been removed on
purpose. Every locktime is now a UNIX timestamp, so locktimes can
always be compared and ordered consistently. The optional ``w``
(wallet) argument is kept only for backward call-site compatibility and
is no longer used.
"""
try:
return int(locktime)
@@ -96,26 +111,23 @@ class Util:
.replace(hour=0, minute=0, second=0, microsecond=0)
.timestamp()
)
if locktime[-1] == "b":
locktime = int(locktime[:-1])
height = 0
if w:
height = Util.get_current_height(w.network)
locktime += int(height)
return int(locktime)
except Exception:
pass
return 0
@staticmethod
def int_locktime(seconds=0, minutes=0, hours=0, days=0, blocks=0):
"""Convert a human duration into seconds (blocks counted as 600s each)."""
def int_locktime(seconds=0, minutes=0, hours=0, days=0):
"""Convert a human duration into seconds.
Note: the ``blocks`` argument was removed together with block-height
support; every duration is now expressed in plain time units.
"""
return int(
seconds
+ minutes * 60
+ hours * 60 * 60
+ days * 60 * 60 * 24
+ blocks * 600
)
# ------------------------------------------------------------------ #
@@ -337,43 +349,35 @@ class Util:
# Locktime arithmetic
# ------------------------------------------------------------------ #
@staticmethod
def chk_locktime(timestamp_to_check, block_height_to_check, locktime):
"""Return True if ``locktime`` is still in the future.
def chk_locktime(timestamp_to_check, locktime):
"""Return True if ``locktime`` (a UNIX timestamp) is still in the future.
Timestamp-style and block-height-style locktimes are compared against
the respective "to_check" reference value.
Only timestamp-based locktimes are supported now; the previous
block-height branch was removed together with block-height support.
"""
# TODO BUG: WHAT HAPPEN AT THRESHOLD?
locktime = int(locktime)
if locktime > LOCKTIME_THRESHOLD and locktime > timestamp_to_check:
return True
elif locktime < LOCKTIME_THRESHOLD and locktime > block_height_to_check:
return True
else:
return False
return locktime > int(timestamp_to_check)
@staticmethod
def anticipate_locktime(locktime, blocks=0, hours=0, days=0):
"""Move a locktime earlier by the given amount.
def anticipate_locktime(locktime, hours=0, days=0):
"""Move a timestamp locktime earlier by the given amount.
Works on both timestamp and block-height locktimes; never returns a
value below 1.
Every locktime is a UNIX timestamp now, so this simply subtracts the
requested time span. The result is never allowed to drop below 1.
Note: the legacy ``blocks`` argument and the block-height branch were
removed; only timestamp arithmetic remains.
"""
locktime = int(locktime)
out = 0
if locktime > LOCKTIME_THRESHOLD:
seconds = blocks * 600 + hours * 3600 + days * 86400
# On Windows datetime.fromtimestamp raises OverflowError past 2038
# (e.g. NLOCKTIME_MAX); clamp to INT32_MAX (Electrum issue #6170).
try:
dt = datetime.fromtimestamp(locktime)
except (OverflowError, OSError, ValueError):
dt = datetime.fromtimestamp(min(locktime, 2 ** 31 - 1))
dt -= timedelta(seconds=seconds)
out = dt.timestamp()
else:
blocks -= hours * 6 + days * 144
out = locktime + blocks
seconds = hours * 3600 + days * 86400
# On Windows datetime.fromtimestamp raises OverflowError past 2038
# (e.g. NLOCKTIME_MAX); clamp to INT32_MAX (Electrum issue #6170).
try:
dt = datetime.fromtimestamp(locktime)
except (OverflowError, OSError, ValueError):
dt = datetime.fromtimestamp(min(locktime, 2 ** 31 - 1))
dt -= timedelta(seconds=seconds)
out = dt.timestamp()
if out < 1:
out = 1

163
bal/core/will.py
View File

@@ -28,7 +28,6 @@ The status flags themselves (the source of truth) stay here; only the mapping
import copy
from electrum.bitcoin import NLOCKTIME_BLOCKHEIGHT_MAX
from electrum.i18n import _
from electrum.logging import Logger, get_logger
from electrum.transaction import (
@@ -458,7 +457,7 @@ class Will:
if (
wi.get_status("VALID")
or wi.get_status("CONFIRMED")
or wi.get_status("PENDING")
or wi.get_status("MEMPOOL")
):
prevout_id = w[2].prevout.txid.hex()
if not inutxo:
@@ -506,7 +505,7 @@ class Will:
if (
not w.father
or willtree[w.father].get_status("CONFIRMED")
or willtree[w.father].get_status("PENDING")
or willtree[w.father].get_status("MEMPOOL")
):
for inp in w.tx.inputs():
inp_str = Util.utxo_to_str(inp)
@@ -516,7 +515,7 @@ class Will:
if height < 0:
Will.set_invalidate(wid, willtree)
elif height == 0:
w.set_status("PENDING", True)
w.set_status("MEMPOOL", True)
else:
w.set_status("CONFIRMED", True)
@@ -558,7 +557,20 @@ class Will:
)
@staticmethod
def check_will(will, all_utxos, wallet, block_to_check, timestamp_to_check):
def check_will(will, all_utxos, wallet, timestamp_to_check):
"""Validate a will against the current wallet state.
Locktimes are always UNIX timestamps (block-height locktimes are no
longer supported by this plugin), so expiry is decided purely by
comparing each transaction's locktime against ``timestamp_to_check``.
Args:
will: The will dictionary (WillItem entries keyed by txid).
all_utxos: The list of UTXOs currently available in the wallet.
wallet: The Electrum wallet object.
timestamp_to_check: The reference UNIX timestamp (usually "now")
used to decide whether any transaction has expired.
"""
Will.add_willtree(will)
utxos_list = Will.utxos_strs(all_utxos)
@@ -566,9 +578,7 @@ class Will:
all_inputs = Will.get_all_inputs(will, only_valid=True)
all_inputs_min_locktime = Will.get_all_inputs_min_locktime(all_inputs)
Will.check_will_expired(
all_inputs_min_locktime, block_to_check, timestamp_to_check
)
Will.check_will_expired(all_inputs_min_locktime, timestamp_to_check)
all_inputs = Will.get_all_inputs(will, only_valid=True)
@@ -583,7 +593,6 @@ class Will:
@staticmethod
def is_will_valid(
will,
block_to_check,
timestamp_to_check,
tx_fees,
all_utxos,
@@ -593,10 +602,29 @@ class Will:
wallet=False,
callback_not_valid_tx=None,
):
"""Check whether the whole will is valid at the given timestamp.
Locktimes are always UNIX timestamps, so the validity check only needs
a single reference timestamp (no block height).
Args:
will: The will dictionary (WillItem entries keyed by txid).
timestamp_to_check: Reference UNIX timestamp (usually "now").
tx_fees: Fee rate used for the dust/coverage check.
all_utxos: The list of UTXOs currently available in the wallet.
heirs: Optional heirs dictionary.
willexecutors: Optional will-executors dictionary.
self_willexecutor: Whether the user acts as their own executor.
wallet: The Electrum wallet object.
callback_not_valid_tx: Optional callback invoked for invalid txs.
Returns:
True if the will is valid; raises an exception otherwise.
"""
heirs = heirs if heirs is not None else {}
willexecutors= willexecutors if willexecutors is not None else {}
Will.check_will(will, all_utxos, wallet, block_to_check, timestamp_to_check)
Will.check_will(will, all_utxos, wallet, timestamp_to_check)
if heirs:
if not Will.check_willexecutors_and_heirs(
will,
@@ -625,25 +653,30 @@ class Will:
return True
@staticmethod
def check_will_expired(all_inputs_min_locktime, block_to_check, timestamp_to_check):
def check_will_expired(all_inputs_min_locktime, timestamp_to_check):
"""Raise WillExpiredException if any valid transaction has expired.
Locktimes are always UNIX timestamps, so a transaction is expired when
its locktime is in the past relative to ``timestamp_to_check``.
Args:
all_inputs_min_locktime: Mapping prevout -> will-item info, used to
find the minimum locktime per input.
timestamp_to_check: Reference UNIX timestamp (usually "now").
"""
_logger.info("check if some transaction is expired")
for prevout_str, wid in all_inputs_min_locktime.items():
for w in wid:
if w[1].get_status("VALID"):
locktime = int(wid[0][1].tx.locktime)
if locktime <= NLOCKTIME_BLOCKHEIGHT_MAX:
if locktime < int(block_to_check):
raise WillExpiredException(
f"Will Expired {wid[0][0]}: {locktime}<{block_to_check}"
)
# Locktimes are always timestamps: expired when in the past.
if locktime < int(timestamp_to_check):
raise WillExpiredException(
f"Will Expired {wid[0][0]}: {locktime}<{timestamp_to_check}"
)
else:
if locktime < int(timestamp_to_check):
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()}")
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")
@@ -723,11 +756,24 @@ class Will:
f"{tx_locktime}->{new_locktime} "
f"on a signed/sent will"
)
# new_locktime < tx_locktime (anticipate) is left to
# check_will_expired -> WillExpiredException.
# ANTICIPATE (new_locktime < tx_locktime): the user
# manually moved the delivery date EARLIER.
# * If the new date is still in the FUTURE, this is
# a plain ANTICIPATE: it falls through here and is
# rebuilt via HeirNotFoundException (no on-chain
# fee). It must NEVER invalidate on-chain, even if
# the will was already signed/sent (A3, owner
# decision D2 = A1).
# * If the new date is in the PAST (relative to the
# check date) the will is genuinely expired and
# check_will_expired -> WillExpiredException handles
# it (on-chain invalidation). That is a different
# situation from "anticipate" and is intentionally
# kept.
#
# new_locktime > tx_locktime on a will that was never
# signed/sent falls through here -> a plain rebuild via
# HeirNotFoundException (no on-chain fee needed).
# signed/sent also falls through here -> a plain rebuild
# via HeirNotFoundException (no on-chain fee needed).
else:
# The will still carries this heir, but the heir is no
# longer present in the current heirs set: the user
@@ -774,6 +820,18 @@ class Will:
class WillItem(Logger):
# Default status flags for an inheritance transaction.
# Each entry maps an internal status key to [human-readable label, default
# boolean value].
#
# A2 changes:
# * "PENDING" was renamed to "MEMPOOL" (the transaction has been seen in
# the Electrum mempool). Old saved wills that still carry the legacy
# "PENDING" key are migrated to "MEMPOOL" in __init__ (see below), so
# nothing is lost.
# * "UPDATED" was added: the transaction was spendable AND valid, and a new
# transaction replaces it while keeping the SAME locktime and SAME heirs.
# UPDATED keeps the VALID flag (see set_status).
STATUS_DEFAULT = {
"ANTICIPATED": ["Anticipated", False],
"BROADCASTED": ["Broadcasted", False],
@@ -786,30 +844,57 @@ class WillItem(Logger):
"EXPORTED": ["Exported", False],
"IMPORTED": ["Imported", False],
"INVALIDATED": ["Invalidated", False],
"PENDING": ["Pending", False],
"MEMPOOL": ["Mempool", False],
"PUSH_FAIL": ["Push failed", False],
"PUSHED": ["Pushed", False],
"REPLACED": ["Replaced", False],
"RESTORED": ["Restored", False],
"UPDATED": ["Updated", False],
"VALID": ["Valid", True],
}
def set_status(self, status, value=True):
# _logger.trace(
# "set status {} - {} {} -> {}".format(
# self._id, status, self.STATUS[status][1], value
# )
# )
"""Set a status flag and apply the related side effects.
Some statuses imply that other statuses must change. The rules below
match the inheritance state machine:
VALID handling:
* INVALIDATED, REPLACED, CONFIRMED, MEMPOOL -> clear VALID
(the transaction can no longer be delivered as a valid will tx).
* ANTICIPATED -> KEEPS VALID. Anticipating only moves the locktime
earlier by 1 day; the transaction stays valid (it is NOT in the
"clear VALID" list on purpose).
* UPDATED -> KEEPS VALID. The transaction is replaced by a new one
that keeps the SAME locktime and SAME heirs, so it stays valid
(it is NOT in the "clear VALID" list on purpose).
Other side effects:
* CONFIRMED, MEMPOOL -> clear INVALIDATED (the tx is on-chain or in
the mempool, so it is no longer considered invalidated).
* PUSHED -> clear PUSH_FAIL and CHECK_FAIL.
* CHECKED -> set PUSHED and clear PUSH_FAIL.
Args:
status: The status key to set (must exist in STATUS).
value: True to set the flag, False to clear it. Defaults to True.
Returns:
The applied boolean value, or None if the flag was already set to
that value (no change).
"""
if self.STATUS[status][1] == bool(value):
return None
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"]:
# NOTE: ANTICIPATED and UPDATED are intentionally NOT in this list,
# so they keep the VALID flag (see docstring above).
if status in ["INVALIDATED", "REPLACED", "CONFIRMED", "MEMPOOL"]:
self.STATUS["VALID"][1] = False
if status in ["CONFIRMED", "PENDING"]:
if status in ["CONFIRMED", "MEMPOOL"]:
self.STATUS["INVALIDATED"][1] = False
if status in ["PUSHED"]:
@@ -845,6 +930,14 @@ class WillItem(Logger):
self.STATUS = copy.deepcopy(WillItem.STATUS_DEFAULT)
for s in self.STATUS:
self.STATUS[s][1] = w.get(s, WillItem.STATUS_DEFAULT[s][1])
# Backward-compatibility migration (A2): the "PENDING" status was
# renamed to "MEMPOOL". Wills saved by older versions of the plugin
# store the flag under the legacy "PENDING" key, so if that key is
# present and set, carry it over to "MEMPOOL". This way no state is
# lost when loading an older will. The new key always wins if both
# happen to be present.
if "MEMPOOL" not in w and w.get("PENDING"):
self.STATUS["MEMPOOL"][1] = True
if not _id:
self._id = self.tx.txid()
else:

42
bal/gui/qt/dialogs.py
View File

@@ -720,10 +720,18 @@ class BalBuildWillDialog(BalDialog):
self.msg_set_invalidating(self.msg_error(e))
def loop_push(self):
# Broadcast is "one-shot" (Group B / B2 follow-up): each selected
# will-executor is contacted ONCE. Transactions that are broadcast
# successfully become PUSHED; transactions whose server fails or times
# out are left as PUSH_FAIL and simply skipped - they are NOT retried
# automatically. A dead will-executor could otherwise never answer and
# make the plugin retry forever. The user can broadcast a failed
# transaction manually later with the "Broadcast" button. Note that
# get_willexecutor_transactions already excludes PUSHED transactions, so
# the successful ones are never re-sent on a subsequent run.
if self._stopping:
return
self.msg_set_pushing(_("Broadcasting"))
retry = False
try:
willexecutors = Willexecutors.get_willexecutor_transactions(
@@ -744,7 +752,6 @@ class BalBuildWillDialog(BalDialog):
# them sequentially after the parallel push, keeping the original
# check logic untouched.
already_present = []
retry_flag = {"value": False}
total = len(selected)
done = {"count": 0}
@@ -770,9 +777,10 @@ class BalBuildWillDialog(BalDialog):
for wid in willexecutor["txsids"]:
self.bal_window.willitems[wid].set_status("PUSHED", True)
else:
# One-shot: mark the failed transactions and move on. They
# are left as PUSH_FAIL (no automatic retry).
for wid in willexecutor["txsids"]:
self.bal_window.willitems[wid].set_status("PUSH_FAIL", True)
retry_flag["value"] = True
done["count"] += 1
# Show the per-server result (Ok/Ko) in bold + color so the
# outcome stands out, keeping the server URL in normal weight.
@@ -781,11 +789,11 @@ class BalBuildWillDialog(BalDialog):
self.msg_set_pushing(_status_line())
def on_timeout(url, willexecutor):
# The global deadline elapsed before this server answered. Mark
# its txs as failed (so the user can retry later) and show it.
# The global deadline elapsed before this server answered. Mark
# its txs as failed and move on (one-shot: no automatic retry).
# The user can broadcast them manually later if desired.
for wid in willexecutor.get("txsids", []):
self.bal_window.willitems[wid].set_status("PUSH_FAIL", True)
retry_flag["value"] = True
self.msg_edit_row(
"{} : {}".format(url, self.msg_error(_("Timeout - no answer")))
)
@@ -820,7 +828,6 @@ class BalBuildWillDialog(BalDialog):
"{}/{} ({}s)".format(done["count"], total,
int(time.time() - push_start))
)
retry = retry_flag["value"]
# Verify the "already present" servers (sequential, original logic).
self.bal_plugin = self.bal_window.bal_plugin
@@ -851,15 +858,18 @@ class BalBuildWillDialog(BalDialog):
row,
)
if retry:
raise Exception("retry")
# One-shot broadcast: we deliberately do NOT raise/retry when some
# will-executors failed. Their transactions stay PUSH_FAIL and are
# left for the user to broadcast manually. This prevents an endless
# retry loop against a will-executor that may never answer.
except Exception as e:
# Only genuine, unexpected errors reach here now (not the old
# "retry" signal). Report the error; do not loop.
self.msg_set_pushing(self.msg_error(e))
self.wait(10)
if not self._stopping:
pass
# self.loop_push()
def invalidate_task(self, password, bal_window, tx):
if self._stopping:
@@ -1038,6 +1048,18 @@ class BalBuildWillDialog(BalDialog):
short to be sure the user noticed the in-dialog line).
"""
self._next_steps_hint = None
# Group B / B2: when AUTO_SIGN is ON the dialog has already signed and
# broadcast the will automatically, so the manual "press Sign/Broadcast"
# hints (and the follow-up popup) would be wrong/confusing. Suppress
# them in that case. When AUTO_SIGN is OFF, keep the previous behaviour
# and guide the user through the remaining manual steps.
try:
if self.bal_window.bal_plugin.AUTO_SIGN.get():
return
except Exception:
# If the setting cannot be read for any reason, fall back to the
# original behaviour (show the manual hints).
pass
try:
need_sign = False
need_push = False

6
bal/gui/qt/lists.py
View File

@@ -551,6 +551,12 @@ class PreviewList(MyTreeView, MessageBoxMixin):
if will:
self.bal_window.check_transactions(will)
self.update()
# NOTE (Group B / B2): signing + broadcasting is already performed
# automatically by BalBuildWillDialog.build_will_task() above (called at
# the start of check()). We must NOT trigger a second sign/broadcast
# cycle here, otherwise the will would be broadcast twice. Whether the
# automatic sign/broadcast runs silently or shows the manual "next step"
# hints is controlled by the AUTO_SIGN setting inside that dialog.
def invalidate_will(self):
self.bal_window.invalidate_will()

27
bal/gui/qt/plugin.py
View File

@@ -389,6 +389,13 @@ class Plugin(BalPlugin):
heir_hide_replaced = BalCheckBox(self.HIDE_REPLACED, on_multiverse_change)
heir_hide_invalidated = BalCheckBox(self.HIDE_INVALIDATED, on_multiverse_change)
# Auto-sign checkbox (Group B / B2). When ticked, the "Check" action
# automatically signs and broadcasts the will after querying the
# will-executor servers. Bound to the persisted AUTO_SIGN config; the
# default is ON (see plugin_base.py).
heir_auto_sign = BalCheckBox(self.AUTO_SIGN)
heir_repush = QPushButton("Rebroadcast transactions")
heir_repush.clicked.connect(partial(self.broadcast_transactions, True))
bal_mode = QComboBox()
@@ -410,18 +417,30 @@ class Plugin(BalPlugin):
2,
"Hide invalidated transactions from will detail and list",
)
add_widget(
grid,
"Auto-sign on Check",
heir_auto_sign,
3,
(
"When checking, automatically sign and broadcast the will "
"transactions to their will-executors.\n"
"The wallet password is requested only if the wallet is "
"encrypted."
),
)
add_widget(
grid,
"Calendar App",
BalLineEdit(self.CALENDAR_APP),
3,
4,
"Default app used to open calendar",
)
add_widget(
grid,
"Event summary",
BalLineEdit(self.EVENT_SUMMARY),
4,
5,
(
"Default message to be used in event summary\n"
"Variables:\n"
@@ -432,9 +451,9 @@ class Plugin(BalPlugin):
)
add_widget(
grid,
"Event sescription",
"Event description",
BalTextEdit(self.EVENT_DESCRIPTION),
5,
6,
(
"Default message to be used in event description\n"
"Variables:\n"

3
bal/gui/qt/theme.py
View File

@@ -22,8 +22,9 @@ status into a colour for the transaction list / detail views.
_STATUS_COLOR_PRIORITY = (
("INVALIDATED", "#f87838"), # orange - tx can no longer be mined
("REPLACED", "#ff97e9"), # pink - superseded by another tx
("UPDATED", "#b266b2"), # light violet - replaced keeping same locktime+heirs
("CONFIRMED", "#bfbfbf"), # grey - already mined
("PENDING", "#ffce30"), # yellow - in mempool, waiting
("MEMPOOL", "#ffce30"), # yellow - seen in the Electrum mempool
)
# Default colour used when no status in the priority list matches.

23
bal/gui/qt/widgets.py
View File

@@ -347,12 +347,16 @@ class LockTimeRawEdit(QLineEdit, _LockTimeEditor):
self.textChanged.connect(self.numbify)
self.isdays = False
self.isyears = False
self.isblocks = False
self.time_edit = time_edit
@staticmethod
def replace_str(text):
return str(text).replace("d", "").replace("y", "").replace("b", "")
"""Strip the relative-time suffixes (d/y) from the text.
Only days ("d") and years ("y") are supported. The block-height
suffix ("b") was removed (A1): locktimes are always timestamps now.
"""
return str(text).replace("d", "").replace("y", "")
def checkbdy(self, s, pos, appendix):
try:
@@ -367,33 +371,29 @@ class LockTimeRawEdit(QLineEdit, _LockTimeEditor):
return pos, s
def numbify(self):
# Only digits plus the day ("d") and year ("y") suffixes are accepted.
# The block-height suffix ("b") was removed (A1): locktimes are always
# UNIX timestamps now, so block-relative input is no longer allowed.
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.blockSignals(True)
self.setText(s)
self.blockSignals(False)
@@ -420,6 +420,11 @@ class LockTimeRawEdit(QLineEdit, _LockTimeEditor):
class LockTimeDateEdit(QDateTimeEdit, _LockTimeEditor):
# GUARD (kept on purpose, A1): NLOCKTIME_BLOCKHEIGHT_MAX is the highest value
# Bitcoin interprets as a *block height*. By forcing the minimum to one above
# it, every locktime entered here is guaranteed to be a UNIX *timestamp*,
# never a block height. This is NOT block-height ordering; it is the
# "bouncer" that prevents block-height values from ever being used again.
min_allowed_value = NLOCKTIME_BLOCKHEIGHT_MAX + 1
max_allowed_value = _LockTimeEditor.get_max_allowed_timestamp()

35
bal/gui/qt/window.py
View File

@@ -368,7 +368,6 @@ class BalWindow:
def check_will(self):
return Will.is_will_valid(
self.willitems,
self.block_to_check,
self.date_to_check,
self.will_settings["baltx_fees"],
self.window.wallet.get_utxos(),
@@ -459,9 +458,10 @@ class BalWindow:
try:
self.date_to_check = BalTimestamp(self.will_settings['threshold']).to_timestamp()
# found = False
self.locktime_blocks = self.bal_plugin.LOCKTIME_BLOCKS.get()
self.current_block = Util.get_current_height(self.wallet.network)
self.block_to_check = 0
# NOTE: block-height tracking removed (A1) - locktimes are always
# UNIX timestamps now, so we no longer read the current block height
# or compute a block_to_check here. Validity is decided purely by
# comparing locktimes against date_to_check (a timestamp).
self.no_willexecutor = self.bal_plugin.NO_WILLEXECUTOR.get()
self.willexecutors = Willexecutors.get_willexecutors(
self.bal_plugin, update=True, bal_window=self, task=False
@@ -479,6 +479,10 @@ class BalWindow:
def build_inheritance_transaction(self, ignore_duplicate=True, keep_original=True):
try:
_logger.info(
"BAL-plugin \u25b8 STEP 1/7: prepare inheritance "
"(validate settings, amounts and locktime)"
)
if self.disable_plugin:
_logger.info("plugin is disabled")
return
@@ -523,11 +527,26 @@ class BalWindow:
return
try:
_logger.info(
"BAL-plugin \u25b8 STEP 2/7: checking if the current will is "
"still coherent (heirs, will-executors, fees, locktime)"
)
self.check_will()
_logger.info(
"BAL-plugin \u25b8 STEP 2/7 result: will is COHERENT, "
"nothing to rebuild"
)
except WillExpiredException:
_logger.info(
"BAL-plugin \u25b8 STEP 2/7 result: will EXPIRED -> "
"invalidating on-chain (real fee)"
)
self.invalidate_will()
return
except NoHeirsException:
_logger.info(
"BAL-plugin \u25b8 STEP 2/7 result: no valid heirs -> abort"
)
return
except WillPostponedException as e:
# The will was already signed/sent and is being postponed.
@@ -536,6 +555,10 @@ class BalWindow:
# can never be used by a will-executor), then press "Prepare"
# again
# to create the new postponed inheritance.
_logger.info(
"BAL-plugin \u25b8 STEP 2/7 result: will POSTPONED on a "
"signed/sent tx -> must invalidate on-chain first (real fee)"
)
_logger.info(f"will postponed: {e}")
self.show_message(
_(
@@ -553,6 +576,10 @@ class BalWindow:
self.invalidate_will()
return
except NotCompleteWillException as e:
_logger.info(
"BAL-plugin \u25b8 STEP 2/7 result: will NOT coherent -> "
"REBUILD needed (no on-chain fee)"
)
_logger.info("{}:{}".format(type(e), e))
message = False
if isinstance(e, HeirChangeException):

2
bal/manifest.json
View File

@@ -1,7 +1,7 @@
{
"name": "bal",
"fullname": "Bitcoin After Life",
"version": "0.3.3",
"version": "0.3.4",
"description": "Provides free and decentralized Bitcoin inheritance support. Build time-locked 'will' transactions that transfer funds to your heirs if you stop refreshing them (dead-man's switch), optionally relayed by will-executor servers.",
"author": "Svatantrya",
"licence": "MIT",