bitcoinafterlife/bal-electrum-plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Compare commits

base: bitcoinafterlife:c0d64201a802ae373415fce17cde5334950a16da
Branches Tags
bitcoinafterlife:main
bitcoinafterlife:refactoring
bitcoinafterlife:0.1.1
bitcoinafterlife:v0.2.0
bitcoinafterlife:v0.1.0
..
compare: bitcoinafterlife:main
Branches Tags
bitcoinafterlife:main
bitcoinafterlife:refactoring
bitcoinafterlife:0.1.1
bitcoinafterlife:v0.2.0
bitcoinafterlife:v0.1.0

No commits in common. "c0d64201a802ae373415fce17cde5334950a16da" and "main" have entirely different histories.
c0d64201a8 ... main

15 changed files with 4022 additions and 1519 deletions
Show Stats Expand all files Collapse all files

1
VERSION Normal file
View File

@ -0,0 +1 @@
0.2.2b

19
__init__.py
View File

@ -1,20 +1 @@
from electrum.i18n import _
import subprocess
from . import bal_resources
BUILD_NUMBER = 1
REVISION_NUMBER = 1
VERSION_NUMBER = 0
def _version():
return f'{VERSION_NUMBER}.{REVISION_NUMBER}-{BUILD_NUMBER}'
version = _version()
author = "Bal Enterprise inc."
fullname = _('B.A.L.')
description = ''.join([
"<img src='",bal_resources.icon_path('bal16x16.png'),"'>", _("Bitcoin After Life"), '<br/>',
_("For more information, visit"),
" <a href=\"https://bitcoin-after.life/\">https://bitcoin-after.life/</a><br/>",
"<p style='font-size:8pt;vertialAlign:bottom'>Version: ", _version(),"</p>"
])
#available_for = ['qt', 'cmdline', 'qml']
available_for = ['qt']

181
bal.py
View File

@ -1,132 +1,149 @@
import random
import os
from hashlib import sha256
from typing import NamedTuple, Optional, Dict, Tuple
import zipfile as zipfile_lib
from electrum.plugin import BasePlugin
from electrum.util import to_bytes, bfh
from electrum import json_db
from electrum.transaction import tx_from_any
from . import util as Util
from . import willexecutors as Willexecutors
import os
def get_will_settings(x):
print(x)
json_db.register_dict('heirs', tuple, None)
json_db.register_dict('will', lambda x: get_will(x), None)
json_db.register_dict('will', dict,None)
json_db.register_dict('will_settings', lambda x:x,None)
#{'rubiconda': ['bcrt1qgv0wu4v6kjzef5mnxfh2m9z6y7mez0ja0tt8mu', '45%', '1y'], 'veronica': ['bcrt1q6vxuvwrt8x5c9u9u29y5uq7frscr0vgc2dy60j', '15%', '1y']}
from electrum.logging import get_logger
def get_will_settings(x):
print(x)
def get_will(x):
try:
#print("______________________________________________________________________________________________________")
#print(x)
x['tx']=tx_from_any(x['tx'])
except Exception as e:
#Util.print_var(x)
raise e
return x
class BalConfig():
def __init__(self, config, name, default):
print("init bal_config")
self.config = config
self.name = name
self.default = default
def get(self,default=None):
v = self.config.get(self.name, default)
if v is None:
if not default is None:
v = default
else:
v = self.default
return v
def set(self,value,save=True):
self.config.set_key(self.name,value,save=save)
class BalPlugin(BasePlugin):
LOCKTIME_TIME = "bal_locktime_time"
LOCKTIME_BLOCKS = "bal_locktime_blocks"
LOCKTIMEDELTA_TIME = "bal_locktimedelta_time"
LOCKTIMEDELTA_BLOCKS = "bal_locktimedelta_blocks"
TX_FEES = "bal_tx_fees"
BROADCAST = "bal_broadcast"
ASK_BROADCAST = "bal_ask_broadcast"
INVALIDATE = "bal_invalidate"
ASK_INVALIDATE = "bal_ask_invalidate"
PREVIEW = "bal_preview"
SAVE_TXS = "bal_save_txs"
WILLEXECUTORS = "bal_willexecutors"
PING_WILLEXECUTORS = "bal_ping_willexecutors"
ASK_PING_WILLEXECUTORS = "bal_ask_ping_willexecutors"
NO_WILLEXECUTOR = "bal_no_willexecutor"
HIDE_REPLACED = "bal_hide_replaced"
HIDE_INVALIDATED = "bal_hide_invalidated"
ALLOW_REPUSH = "bal_allow_repush"
LATEST_VERSION = '1'
KNOWN_VERSIONS = ('0', '1')
assert LATEST_VERSION in KNOWN_VERSIONS
def version():
try:
f=""
with open("VERSION","r") as f:
f = str(f.readline())
return f
except:
return "unknown"
SIZE = (159, 97)
def __init__(self, parent, config, name):
print("init bal_plugin")
self.logger = get_logger(__name__)
BasePlugin.__init__(self, parent, config, name)
self.base_dir = os.path.join(config.electrum_path(), 'bal')
self.plugin_dir = os.path.split(os.path.realpath(__file__))[0]
zipfile="/".join(self.plugin_dir.split("/")[:-1])
#print("real path",os.path.realpath(__file__))
#self.logger.info(self.base_dir)
#print("base_dir:", self.base_dir)
#print("suca:",zipfile)
#print("plugin_dir:", self.plugin_dir)
import sys
sys.path.insert(0, zipfile)
#print("sono state listate?")
self.parent = parent
self.config = config
self.name = name
DEFAULT_SETTINGS={
LOCKTIME_TIME: 90,
LOCKTIME_BLOCKS: 144*90,
LOCKTIMEDELTA_TIME: 7,
LOCKTIMEDELTA_BLOCKS:144*7,
TX_FEES: 100,
BROADCAST: True,
ASK_BROADCAST: True,
INVALIDATE: True,
ASK_INVALIDATE: True,
PREVIEW: True,
SAVE_TXS: True,
PING_WILLEXECUTORS: False,
ASK_PING_WILLEXECUTORS: False,
NO_WILLEXECUTOR: False,
HIDE_REPLACED:True,
HIDE_INVALIDATED:True,
ALLOW_REPUSH: False,
WILLEXECUTORS: {
'http://bitcoin-after.life:9137': {
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)
self.LOCKTIME_BLOCKS = BalConfig(config, "bal_locktime_blocks", 144*90)
self.LOCKTIMEDELTA_TIME = BalConfig(config, "bal_locktimedelta_time", 7)
self.LOCKTIMEDELTA_BLOCKS = BalConfig(config, "bal_locktimedelta_blocks", 144*7)
self.ENABLE_MULTIVERSE = BalConfig(config, "bal_enable_multiverse", False)
self.TX_FEES = BalConfig(config, "bal_tx_fees", 100)
self.INVALIDATE = BalConfig(config, "bal_invalidate", True)
self.ASK_INVALIDATE = BalConfig(config, "bal_ask_invalidate", True)
self.PREVIEW = BalConfig(config, "bal_preview", True)
self.SAVE_TXS = BalConfig(config, "bal_save_txs", True)
self.WILLEXECUTORS = BalConfig(config, "bal_willexecutors", True)
self.PING_WILLEXECUTORS = BalConfig(config, "bal_ping_willexecutors", True)
self.ASK_PING_WILLEXECUTORS = BalConfig(config, "bal_ask_ping_willexecutors", True)
self.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)
self.ALLOW_REPUSH = BalConfig(config, "bal_allow_repush", True)
self.FIRST_EXECUTION = BalConfig(config, "bal_first_execution", True)
self.WILLEXECUTORS = BalConfig(config, "bal_willexecutors", {
"mainnet": {
'https://we.bitcoin-after.life': {
"base_fee": 100000,
"status": "New",
"info":"Bitcoin After Life Will Executor",
"address":"bcrt1qa5cntu4hgadw8zd3n6sq2nzjy34sxdtd9u0gp7",
"selected":True
}
},
}
})
self.WILL_SETTINGS = BalConfig(config, "bal_will_settings", {
'baltx_fees':100,
'threshold':'180d',
'locktime':'1y',
})
LATEST_VERSION = '1'
KNOWN_VERSIONS = ('0', '1')
assert LATEST_VERSION in KNOWN_VERSIONS
SIZE = (159, 97)
self._hide_invalidated= self.HIDE_INVALIDATED.get()
self._hide_replaced= self.HIDE_REPLACED.get()
def __init__(self, parent, config, name):
self.logger= get_logger(__name__)
BasePlugin.__init__(self, parent, config, name)
self.base_dir = os.path.join(config.electrum_path(), 'bal')
self.logger.info(self.base_dir)
self.parent = parent
self.config = config
self.name = name
self._hide_invalidated= self.config_get(self.HIDE_INVALIDATED)
self._hide_replaced= self.config_get(self.HIDE_REPLACED)
self.plugin_dir = os.path.split(os.path.realpath(__file__))[0]
def resource_path(self,*parts):
return os.path.join(self.plugin_dir, *parts)
def config_get(self,key):
v = self.config.get(key,None)
if v is None:
self.config.set_key(key,self.DEFAULT_SETTINGS[key],save=True)
v = self.DEFAULT_SETTINGS[key]
return v
def hide_invalidated(self):
self._hide_invalidated = not self._hide_invalidated
self.config.set_key(BalPlugin.HIDE_INVALIDATED,self.hide_invalidated,save=True)
self.HIDE_INVALIDATED.set(self._hide_invalidated)
def hide_replaced(self):
self._hide_replaced = not self._hide_replaced
self.config.set_key(BalPlugin.HIDE_REPLACED,self.hide_invalidated,save=True)
self.HIDE_REPLACED.set(self._hide_replaced)
def default_will_settings(self):
return {
'tx_fees':100,
'threshold':'180d',
'locktime':'1y',
}
def validate_will_settings(self,will_settings):
if int(will_settings.get('tx_fees',1))<1:
will_settings['tx_fees']=1
print(type(will_settings))
print(will_settings.get('baltx_fees',1),1)
if int(will_settings.get('baltx_fees',1))<1:
will_settings['baltx_fees']=1
if not will_settings.get('threshold'):
will_settings['threshold']='180d'
if not will_settings.get('locktime')=='':
will_settings['locktime']='1y'
return will_settings
def default_will_settings(self):
return {
'baltx_fees':100,
'threshold':'180d',
'locktime':'1y'
}

2
bal_resources.py
View File

@ -2,7 +2,7 @@ import os
PLUGIN_DIR = os.path.split(os.path.realpath(__file__))[0]
DEFAULT_ICON = 'bal32x32.png'
DEFAULT_ICON_PATH = 'icons'
DEFAULT_ICON_PATH = ''
def icon_path(icon_basename: str = DEFAULT_ICON):

21
balqt/baldialog.py
View File

@ -95,25 +95,8 @@ class bal_checkbox(QCheckBox):
def __init__(self, plugin,variable,window=None):
QCheckBox.__init__(self)
self.setChecked(plugin.config_get(variable))
window=window
def on_check(v):
plugin.config.set_key(variable, v == Qt.CheckState.Checked, save=True)
if window:
plugin._hide_invalidated= plugin.config_get(plugin.HIDE_INVALIDATED)
plugin._hide_replaced= plugin.config_get(plugin.HIDE_REPLACED)
window.update_all()
plugin.config.set_key(variable, v == 2)
plugin.config_get(variable)
self.stateChanged.connect(on_check)
#TODO IMPLEMENT PREVIEW DIALOG
#tx list display txid, willexecutor, qrcode, button to sign
# :def preview_dialog(self, txs):
def preview_dialog(self, txs):
w=PreviewDialog(self,txs)
w.exec()
return w
def add_info_from_will(self,tx):
for input in tx.inputs():
pass

2
balqt/closedialog.py
View File

@ -225,7 +225,7 @@ class BalCloseDialog(BalDialog):
#self._stopping=True
#self.on_success_phase2()
# return
_logger.debug("have to sign",self.have_to_sign)
_logger.debug("have to sign {}".format(self.have_to_sign))
password=None
if self.have_to_sign is None:
self.msg_set_invalidating()

1
balqt/willexecutor_dialog.py
View File

@ -199,7 +199,6 @@ class WillExecutorDialog(BalDialog,MessageBoxMixin):
def __init__(self, bal_window):
BalDialog.__init__(self,bal_window.window)
self.bal_plugin = bal_window.bal_plugin
self.gui_object = self.bal_plugin.gui_object
self.config = self.bal_plugin.config
self.window = bal_window.window
self.bal_window = bal_window

25
heirs.py
View File

@ -14,9 +14,9 @@ from electrum.transaction import PartialTxInput, PartialTxOutput,TxOutpoint,Part
import datetime
import urllib.request
import urllib.parse
from .bal import BalPlugin
from . import util as Util
from . import willexecutors as Willexecutors
import random
from .util import Util
from .willexecutors import Willexecutors
if TYPE_CHECKING:
from .wallet_db import WalletDB
from .simple_config import SimpleConfig
@ -38,6 +38,7 @@ def reduce_outputs(in_amount, out_amount, fee, outputs):
for output in outputs:
output.value = math.floor((in_amount-fee)/out_amount * output.value)
"""
#TODO: put this method inside wallet.db to replace or complete get_locktime_for_new_transaction
def get_current_height(network:'Network'):
#if no network or not up to date, just set locktime to zero
@ -57,7 +58,7 @@ def get_current_height(network:'Network'):
# discourage "fee sniping"
height = min(chain_height, server_height)
return height
"""
@ -112,7 +113,9 @@ def prepare_transactions(locktimes, available_utxos, fees, wallet):
change = get_change_output(wallet, in_amount, out_amount, fee)
if change:
outputs.append(change)
for i in range(0,100):
random.shuffle(outputs)
print(outputs)
tx = PartialTransaction.from_io(used_utxos, outputs, locktime=Util.parse_locktime_string(locktime,wallet), version=2)
if len(description)>0: tx.description = description[:-1]
else: tx.description = ""
@ -385,8 +388,8 @@ class Heirs(dict, Logger):
if not utxos:
utxos = wallet.get_utxos()
willexecutors = Willexecutors.get_willexecutors(bal_plugin) or {}
self.decimal_point=bal_plugin.config.get_decimal_point()
no_willexecutors = bal_plugin.config_get(BalPlugin.NO_WILLEXECUTOR)
self.decimal_point=bal_plugin.get_decimal_point()
no_willexecutors = bal_plugin.NO_WILLEXECUTOR.get()
for utxo in utxos:
if utxo.value_sats()> 0*tx_fees:
balance += utxo.value_sats()
@ -563,10 +566,7 @@ class Heirs(dict, Logger):
def validate_amount(amount):
try:
if Util.is_perc(amount):
famount = float(amount[:-1])
else:
famount = float(amount)
famount = float(amount[:-1]) if Util.is_perc(amount) else float(amount)
if famount <= 0.00000001:
raise AmountNotValid(f"amount have to be positive {famount} < 0")
except Exception as e:
@ -575,9 +575,8 @@ class Heirs(dict, Logger):
def validate_locktime(locktime,timestamp_to_check=False):
try:
locktime = Util.parse_locktime_string(locktime,None)
if timestamp_to_check:
if locktime < timestamp_to_check:
if Util.parse_locktime_string(locktime,None) < timestamp_to_check:
raise HeirExpiredException()
except Exception as e:
raise LocktimeNotValid(f"locktime string not properly formatted, {e}")

9
manifest.json Normal file
View File

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

2701
qt.py
View File

File diff suppressed because it is too large Load Diff

81
util.py
View File

@ -8,6 +8,7 @@ import urllib.parse
from electrum.util import write_json_file,FileImportFailed,FileExportFailed
LOCKTIME_THRESHOLD = 500000000
class Util:
def locktime_to_str(locktime):
try:
locktime=int(locktime)
@ -16,7 +17,6 @@ def locktime_to_str(locktime):
return dt
except Exception as e:
#print(e)
pass
return str(locktime)
@ -27,7 +27,6 @@ def str_to_locktime(locktime):
else: return int(locktime)
except Exception as e:
pass
#print(e)
dt_object = datetime.fromisoformat(locktime)
timestamp = dt_object.timestamp()
return int(timestamp)
@ -38,7 +37,6 @@ def parse_locktime_string(locktime,w=None):
except Exception as e:
pass
#print("parse_locktime_string",e)
try:
now = datetime.now()
if locktime[-1] == 'y':
@ -49,12 +47,11 @@ def parse_locktime_string(locktime,w=None):
locktime = int(locktime[:-1])
height = 0
if w:
height = get_current_height(w.network)
height = Util.get_current_height(w.network)
locktime+=int(height)
return int(locktime)
except Exception as e:
print("parse_locktime_string",e)
#raise e
pass
return 0
@ -62,7 +59,7 @@ def int_locktime(seconds=0,minutes=0,hours=0, days=0, blocks = 0):
return int(seconds + minutes*60 + hours*60*60 + days*60*60*24 + blocks * 600)
def encode_amount(amount, decimal_point):
if is_perc(amount):
if Util.is_perc(amount):
return amount
else:
try:
@ -71,7 +68,7 @@ def encode_amount(amount, decimal_point):
return 0
def decode_amount(amount,decimal_point):
if is_perc(amount):
if Util.is_perc(amount):
return amount
else:
num=8-decimal_point
@ -111,7 +108,6 @@ def cmp_willexecutor(willexecutora,willexecutorb):
return False
def search_heir_by_values(heirs,heir,values):
#print()
for h,v in heirs.items():
found = False
for val in values:
@ -133,13 +129,12 @@ def cmp_heirs_by_values(heirsa,heirsb,values,exclude_willexecutors=False,reverse
if (exclude_willexecutors and not "w!ll3x3c\"" in heira) or not exclude_willexecutors:
found = False
for heirb in heirsb:
if cmp_heir_by_values(heirsa[heira],heirsb[heirb],values):
if Util.cmp_heir_by_values(heirsa[heira],heirsb[heirb],values):
found=True
if not found:
#print(f"not_found {heira}--{heirsa[heira]}")
return False
if reverse:
return cmp_heirs_by_values(heirsb,heirsa,values,exclude_willexecutors=exclude_willexecutors,reverse=False)
return Util.cmp_heirs_by_values(heirsb,heirsa,values,exclude_willexecutors=exclude_willexecutors,reverse=False)
else:
return True
@ -148,10 +143,10 @@ def cmp_heirs(heirsa,heirsb,cmp_function = lambda x,y: x[0]==y[0] and x[3]==y[3]
for heir in heirsa:
if not "w!ll3x3c\"" in heir:
if not heir in heirsb or not cmp_function(heirsa[heir],heirsb[heir]):
if not search_heir_by_values(heirsb,heirsa[heir],[0,3]):
if not Util.search_heir_by_values(heirsb,heirsa[heir],[0,3]):
return False
if reverse:
return cmp_heirs(heirsb,heirsa,cmp_function,False)
return Util.cmp_heirs(heirsb,heirsa,cmp_function,False)
else:
return True
except Exception as e:
@ -162,7 +157,7 @@ def cmp_inputs(inputsa,inputsb):
if len(inputsa) != len(inputsb):
return False
for inputa in inputsa:
if not in_utxo(inputa,inputsb):
if not Util.in_utxo(inputa,inputsb):
return False
return True
@ -170,15 +165,15 @@ def cmp_outputs(outputsa,outputsb,willexecutor_output = None):
if len(outputsa) != len(outputsb):
return False
for outputa in outputsa:
if not cmp_output(outputa,willexecutor_output):
if not in_output(outputa,outputsb):
if not Util.cmp_output(outputa,willexecutor_output):
if not Util.in_output(outputa,outputsb):
return False
return True
def cmp_txs(txa,txb):
if not cmp_inputs(txa.inputs(),txb.inputs()):
if not Util.cmp_inputs(txa.inputs(),txb.inputs()):
return False
if not cmp_outputs(txa.outputs(),txb.outputs()):
if not Util.cmp_outputs(txa.outputs(),txb.outputs()):
return False
return True
@ -186,30 +181,19 @@ def get_value_amount(txa,txb):
outputsa=txa.outputs()
outputsb=txb.outputs()
value_amount = 0
#if len(outputsa) != len(outputsb):
# print("outputlen is different")
# return False
for outa in outputsa:
same_amount,same_address = in_output(outa,txb.outputs())
same_amount,same_address = Util.in_output(outa,txb.outputs())
if not (same_amount or same_address):
#print("outa notin txb", same_amount,same_address)
return False
if same_amount and same_address:
value_amount+=outa.value
if same_amount:
pass
#print("same amount")
if same_address:
pass
#print("same address")
return value_amount
#not needed
#for outb in outputsb:
# if not in_output(outb,txa.outputs()):
# print("outb notin txb")
# return False
@ -244,8 +228,8 @@ def cmp_locktime(locktimea,locktimeb):
return 0
strlocktime = str(locktimea)
strlocktimeb = str(locktimeb)
intlocktimea = str_to_locktime(strlocktimea)
intlocktimeb = str_to_locktime(strlocktimeb)
intlocktimea = Util.str_to_locktime(strlocktimea)
intlocktimeb = Util.str_to_locktime(strlocktimeb)
if locktimea[-1] in "ydb":
if locktimeb[-1] == locktimea[-1]:
return int(strlocktimea[-1])-int(strlocktimeb[-1])
@ -268,8 +252,7 @@ def get_lowest_locktimes(locktimes):
sorted_timestamp=[]
sorted_block=[]
for l in locktimes:
#print("locktime:",parse_locktime_string(l))
l=parse_locktime_string(l)
l=Util.parse_locktime_string(l)
if l < LOCKTIME_THRESHOLD:
bisect.insort(sorted_block,l)
else:
@ -278,11 +261,11 @@ def get_lowest_locktimes(locktimes):
return sorted(sorted_timestamp), sorted(sorted_block)
def get_lowest_locktimes_from_will(will):
return get_lowest_locktimes(get_locktimes(will))
return Util.get_lowest_locktimes(Util.get_locktimes(will))
def search_willtx_per_io(will,tx):
for wid, w in will.items():
if cmp_txs(w['tx'],tx['tx']):
if Util.cmp_txs(w['tx'],tx['tx']):
return wid,w
return None, None
@ -304,17 +287,16 @@ def utxo_to_str(utxo):
return str(utxo)
def cmp_utxo(utxoa,utxob):
utxoa=utxo_to_str(utxoa)
utxob=utxo_to_str(utxob)
utxoa=Util.utxo_to_str(utxoa)
utxob=Util.utxo_to_str(utxob)
if utxoa == utxob:
#if utxoa.prevout.txid==utxob.prevout.txid and utxoa.prevout.out_idx == utxob.prevout.out_idx:
return True
else:
return False
def in_utxo(utxo, utxos):
for s_u in utxos:
if cmp_utxo(s_u,utxo):
if Util.cmp_utxo(s_u,utxo):
return True
return False
@ -329,7 +311,7 @@ def cmp_output(outputa,outputb):
def in_output(output,outputs):
for s_o in outputs:
if cmp_output(s_o,output):
if Util.cmp_output(s_o,output):
return True
return False
@ -345,11 +327,9 @@ def din_output(out,outputs):
if int(out.value) == int(s_o.value):
same_amount.append(s_o)
if out.address==s_o.address:
#print("SAME_:",out.address,s_o.address)
return True, True
else:
pass
#print("NOT SAME_:",out.address,s_o.address)
if len(same_amount)>0:
return True, False
@ -417,11 +397,10 @@ def print_var(var,name = "",veryverbose=False):
def print_utxo(utxo, name = ""):
print(f"---utxo-{name}---")
print_var(utxo,name)
print_prevout(utxo.prevout,name)
print_var(utxo.script_sig,f"{name}-script-sig")
print_var(utxo.witness,f"{name}-witness")
#print("madonnamaiala_TXInput__scriptpubkey:",utxo._TXInput__scriptpubkey)
Util.print_var(utxo,name)
Util.print_prevout(utxo.prevout,name)
Util.print_var(utxo.script_sig,f"{name}-script-sig")
Util.print_var(utxo.witness,f"{name}-witness")
print("_TxInput__address:",utxo._TxInput__address)
print("_TxInput__scriptpubkey:",utxo._TxInput__scriptpubkey)
print("_TxInput__value_sats:",utxo._TxInput__value_sats)
@ -429,8 +408,8 @@ def print_utxo(utxo, name = ""):
def print_prevout(prevout, name = ""):
print(f"---prevout-{name}---")
print_var(prevout,f"{name}-prevout")
print_var(prevout._asdict())
Util.print_var(prevout,f"{name}-prevout")
Util.print_var(prevout._asdict())
print(f"---prevout-end {name}---")
def export_meta_gui(electrum_window: 'ElectrumWindow', title, exporter):

69
wallet_util/bal_wallet_utils.py Executable file
View File

@ -0,0 +1,69 @@
#!env/bin/python3
from electrum.storage import WalletStorage
from electrum.util import MyEncoder
import json
import sys
import getpass
import os
default_fees= 100
def fix_will_settings_tx_fees(json_wallet):
tx_fees = json_wallet.get('will_settings',{}).get('tx_fees',False)
have_to_update=False
if tx_fees:
json_wallet['will_settings']['baltx_fees']=tx_fees
del json_wallet['will_settings']['tx_fees']
have_to_update=True
for txid,willitem in json_wallet['will'].items():
tx_fees=willitem.get('tx_fees',False)
if tx_fees:
json_wallet['will'][txid]['baltx_fees']=tx_fees
del json_wallet['will'][txid]['tx_fees']
have_to_update=True
return have_to_update
def uninstall_bal(json_wallet):
del json_wallet['will_settings']
del json_wallet['will']
del json_wallet['heirs']
return True
def save(json_wallet,storage):
human_readable=not storage.is_encrypted()
storage.write(json.dumps(
json_wallet,
indent=4 if human_readable else None,
sort_keys=bool(human_readable),
cls=MyEncoder,
))
def read_wallet(path,password=False):
storage=WalletStorage(path)
if storage.is_encrypted():
if password==False:
password = getpass.getpass("Enter wallet password: ", stream = None)
storage.decrypt(password)
data=storage.read()
json_wallet=json.loads('['+data+']')[0]
return json_wallet
if __name__ == '__main__':
if len(sys.argv) <3:
print("usage: ./bal_wallet_utils <command> <wallet path>")
print("available commands: uninstall, fix")
exit(1)
if not os.path.exists(sys.argv[2]):
print("Error: wallet not found")
exit(1)
command = sys.argv[1]
path = sys.argv[2]
json_wallet = read_wallet(path)
have_to_save=False
if command == 'fix':
have_to_save = fix_will_settings_tx_fees(json_wallet)
if command == 'uninstall':
have_to_save = uninstall_bal(json_wallet)
if have_to_save:
save(json_wallet,storage)
else:
print("nothing to do")

188
wallet_util/bal_wallet_utils_qt.py Executable file
View File

@ -0,0 +1,188 @@
#!/usr/bin/env python3
import sys
import os
import json
from PyQt6.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout,
QLabel, QLineEdit, QPushButton, QWidget, QFileDialog,
QGroupBox, QTextEdit)
from PyQt6.QtCore import Qt
from electrum.storage import WalletStorage
from electrum.util import MyEncoder
from bal_wallet_utils import fix_will_settings_tx_fees,uninstall_bal,read_wallet
class WalletUtilityGUI(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('BAL Wallet Utility')
self.setFixedSize(500, 400)
# Central widget
central_widget = QWidget()
self.setCentralWidget(central_widget)
# Main layout
layout = QVBoxLayout(central_widget)
# Wallet input group
wallet_group = QGroupBox("Wallet Settings")
wallet_layout = QVBoxLayout(wallet_group)
# Wallet path
wallet_path_layout = QHBoxLayout()
wallet_path_layout.addWidget(QLabel("Wallet Path:"))
self.wallet_path_edit = QLineEdit()
self.wallet_path_edit.setPlaceholderText("Select wallet path...")
wallet_path_layout.addWidget(self.wallet_path_edit)
self.browse_btn = QPushButton("Browse...")
self.browse_btn.clicked.connect(self.browse_wallet)
wallet_path_layout.addWidget(self.browse_btn)
wallet_layout.addLayout(wallet_path_layout)
# Password
password_layout = QHBoxLayout()
password_layout.addWidget(QLabel("Password:"))
self.password_edit = QLineEdit()
self.password_edit.setEchoMode(QLineEdit.EchoMode.Password)
self.password_edit.setPlaceholderText("Enter password (if encrypted)")
password_layout.addWidget(self.password_edit)
wallet_layout.addLayout(password_layout)
layout.addWidget(wallet_group)
# Output area
output_group = QGroupBox("Output")
output_layout = QVBoxLayout(output_group)
self.output_text = QTextEdit()
self.output_text.setReadOnly(True)
output_layout.addWidget(self.output_text)
layout.addWidget(output_group)
# Action buttons
buttons_layout = QHBoxLayout()
self.fix_btn = QPushButton("Fix")
self.fix_btn.clicked.connect(self.fix_wallet)
self.fix_btn.setEnabled(False)
buttons_layout.addWidget(self.fix_btn)
self.uninstall_btn = QPushButton("Uninstall")
self.uninstall_btn.clicked.connect(self.uninstall_wallet)
self.uninstall_btn.setEnabled(False)
buttons_layout.addWidget(self.uninstall_btn)
layout.addLayout(buttons_layout)
# Connections to enable buttons when path is entered
self.wallet_path_edit.textChanged.connect(self.check_inputs)
def browse_wallet(self):
file_path, _ = QFileDialog.getOpenFileName(
self,
"Select Wallet",
"*",
"Electrum Wallet (*)"
)
if file_path:
self.wallet_path_edit.setText(file_path)
def check_inputs(self):
wallet_path = self.wallet_path_edit.text().strip()
has_path = bool(wallet_path) and os.path.exists(wallet_path)
self.fix_btn.setEnabled(has_path)
self.uninstall_btn.setEnabled(has_path)
def log_message(self, message):
self.output_text.append(message)
def fix_wallet(self):
self.process_wallet('fix')
def uninstall_wallet(self):
self.log_message("WARNING: This will remove all BAL settings. This operation cannot be undone.")
self.process_wallet('uninstall')
def process_wallet(self, command):
wallet_path = self.wallet_path_edit.text().strip()
password = self.password_edit.text()
if not wallet_path:
self.log_message("ERROR: Please enter wallet path")
return
if not os.path.exists(wallet_path):
self.log_message("ERROR: Wallet not found")
return
try:
self.log_message(f"Processing wallet: {wallet_path}")
storage = WalletStorage(wallet_path)
# Decrypt if necessary
if storage.is_encrypted():
if not password:
self.log_message("ERROR: Wallet is encrypted, please enter password")
return
try:
storage.decrypt(password)
self.log_message("Wallet decrypted successfully")
except Exception as e:
self.log_message(f"ERROR: Wrong password: {str(e)}")
return
# Read wallet
data = storage.read()
json_wallet = json.loads('[' + data + ']')[0]
have_to_save = False
message = ""
if command == 'fix':
have_to_save = fix_will_settings_tx_fees(json_wallet)
message = "Fix applied successfully" if have_to_save else "No fix needed"
elif command == 'uninstall':
have_to_save = uninstall_bal(json_wallet)
message = "BAL uninstalled successfully" if have_to_save else "No BAL settings found to uninstall"
if have_to_save:
try:
save_wallet(json_wallet, storage)
self.log_message(f"SUCCESS: {message}")
except Exception as e:
self.log_message(f"Save error: {str(e)}")
else:
self.log_message(f"INFO: {message}")
except Exception as e:
error_msg = f"ERROR: Processing failed: {str(e)}"
self.log_message(error_msg)
def main():
app = QApplication(sys.argv)
# Check if dependencies are available
try:
from electrum.storage import WalletStorage
from electrum.util import MyEncoder
except ImportError as e:
print(f"ERROR: Cannot import Electrum dependencies: {str(e)}")
return 1
window = WalletUtilityGUI()
window.show()
return app.exec()
if __name__ == '__main__':
sys.exit(main())

138
will.py
View File

@ -1,7 +1,7 @@
import copy
from . import willexecutors as Willexecutors
from . import util as Util
from .willexecutors import Willexecutors
from .util import Util
from electrum.i18n import _
@ -15,6 +15,7 @@ MIN_LOCKTIME = 1
MIN_BLOCK = 1
_logger = get_logger(__name__)
class Will:
#return an array with the list of children
def get_children(will,willid):
out = []
@ -29,7 +30,7 @@ def get_children(will,willid):
#build a tree with parent transactions
def add_willtree(will):
for willid in will:
will[willid].children = get_children(will,willid)
will[willid].children = Will.get_children(will,willid)
for child in will[willid].children:
if not will[child[0]].father:
will[child[0]].father = willid
@ -65,12 +66,14 @@ def get_tx_from_any(x):
def add_info_from_will(will,wid,wallet):
if isinstance(will[wid].tx,str):
will[wid].tx = get_tx_from_any(will[wid].tx)
will[wid].tx = Will.get_tx_from_any(will[wid].tx)
if wallet:
will[wid].tx.add_info_from_wallet(wallet)
for txin in will[wid].tx.inputs():
txid = txin.prevout.txid.hex()
if txid in will:
#print(will[txid].tx.outputs())
#print(txin.prevout.out_idx)
change = will[txid].tx.outputs()[txin.prevout.out_idx]
txin._trusted_value_sats = change.value
try:
@ -87,8 +90,11 @@ def normalize_will(will,wallet = None,others_inputs = {}):
to_delete = []
to_add = {}
#add info from wallet
willitems={}
for wid in will:
add_info_from_will(will,wid,wallet)
Will.add_info_from_will(will,wid,wallet)
willitems[wid]=WillItem(will[wid])
will=willitems
errors ={}
for wid in will:
@ -109,10 +115,10 @@ def normalize_will(will,wallet = None,others_inputs = {}):
outputs = will[wid].tx.outputs()
ow=will[wid]
ow.normalize_locktime(others_inputs)
will[wid]=ow.to_dict()
will[wid]=WillItem(ow.to_dict())
for i in range(0,len(outputs)):
change_input(will,wid,i,outputs[i],others_inputs,to_delete,to_add)
Will.change_input(will,wid,i,outputs[i],others_inputs,to_delete,to_add)
to_delete.append(wid)
to_add[ow.tx.txid()]=ow.to_dict()
@ -141,23 +147,16 @@ def check_anticipate(ow:'WillItem',nw:'WillItem'):
anticipate = Util.anticipate_locktime(ow.tx.locktime,days=1)
if int(nw.tx.locktime) >= int(anticipate):
if Util.cmp_heirs_by_values(ow.heirs,nw.heirs,[0,1],exclude_willexecutors = True):
print("same heirs",ow._id,nw._id)
if nw.we and ow.we:
if ow.we['url'] == nw.we['url']:
print("same willexecutors", ow.we['url'],nw.we['url'])
if int(ow.we['base_fee'])>int(nw.we['base_fee']):
print("anticipate")
return anticipate
else:
if int(ow.tx_fees) != int(nw.tx_fees):
return anticipate
else:
print("keep the same")
#_logger.debug("ow,base fee > nw.base_fee")
ow.tx.locktime
else:
#_logger.debug("ow.we['url']({ow.we['url']}) == nw.we['url']({nw.we['url']})")
print("keep the same")
ow.tx.locktime
else:
if nw.we == ow.we:
@ -188,7 +187,7 @@ def change_input(will, otxid, idx, change,others_inputs,to_delete,to_append):
if isinstance(w.tx,Transaction):
will[wid].tx = PartialTransaction.from_tx(w.tx)
will[wid].tx.set_rbf(True)
will[wid].tx._inputs[i]=new_input(wid,idx,change)
will[wid].tx._inputs[i]=Will.new_input(wid,idx,change)
found = True
if found == True:
pass
@ -199,7 +198,7 @@ def change_input(will, otxid, idx, change,others_inputs,to_delete,to_append):
to_append[new_txid]=will[wid]
outputs = will[wid].tx.outputs()
for i in range(0,len(outputs)):
change_input(will, wid, i, outputs[i],others_inputs,to_delete,to_append)
Will.change_input(will, wid, i, outputs[i],others_inputs,to_delete,to_append)
def get_all_inputs(will,only_valid = False):
all_inputs = {}
@ -234,7 +233,7 @@ def search_anticipate_rec(will,old_inputs):
redo = False
to_delete = []
to_append = {}
new_inputs = get_all_inputs(will,only_valid = True)
new_inputs = Will.get_all_inputs(will,only_valid = True)
for nid,nwi in will.items():
if nwi.search_anticipate(new_inputs) or nwi.search_anticipate(old_inputs):
if nid != nwi.tx.txid():
@ -243,7 +242,7 @@ def search_anticipate_rec(will,old_inputs):
to_append[nwi.tx.txid()] = nwi
outputs = nwi.tx.outputs()
for i in range(0,len(outputs)):
change_input(will,nid,i,outputs[i],new_inputs,to_delete,to_append)
Will.change_input(will,nid,i,outputs[i],new_inputs,to_delete,to_append)
for w in to_delete:
@ -254,25 +253,25 @@ def search_anticipate_rec(will,old_inputs):
for k,w in to_append.items():
will[k]=w
if redo:
search_anticipate_rec(will,old_inputs)
Will.search_anticipate_rec(will,old_inputs)
def update_will(old_will,new_will):
all_old_inputs = get_all_inputs(old_will,only_valid=True)
all_inputs_min_locktime = get_all_inputs_min_locktime(all_old_inputs)
all_new_inputs = get_all_inputs(new_will)
all_old_inputs = Will.get_all_inputs(old_will,only_valid=True)
all_inputs_min_locktime = Will.get_all_inputs_min_locktime(all_old_inputs)
all_new_inputs = Will.get_all_inputs(new_will)
#check if the new input is already spent by other transaction
#if it is use the same locktime, or anticipate.
search_anticipate_rec(new_will,all_old_inputs)
Will.search_anticipate_rec(new_will,all_old_inputs)
other_inputs = get_all_inputs(old_will,{})
other_inputs = Will.get_all_inputs(old_will,{})
try:
normalize_will(new_will,others_inputs=other_inputs)
Will.normalize_will(new_will,others_inputs=other_inputs)
except Exception as e:
raise e
for oid in only_valid(old_will):
for oid in Will.only_valid(old_will):
if oid in new_will:
new_heirs = new_will[oid].heirs
new_we = new_will[oid].we
@ -280,11 +279,9 @@ def update_will(old_will,new_will):
new_will[oid]=old_will[oid]
new_will[oid].heirs = new_heirs
new_will[oid].we = new_we
print(f"found {oid}")
continue
else:
print(f"not found {oid}")
continue
def get_higher_input_for_tx(will):
@ -301,8 +298,8 @@ def get_higher_input_for_tx(will):
return out
def invalidate_will(will,wallet,fees_per_byte):
will_only_valid = only_valid_list(will)
inputs = get_all_inputs(will_only_valid)
will_only_valid = Will.only_valid_list(will)
inputs = Will.get_all_inputs(will_only_valid)
utxos = wallet.get_utxos()
filtered_inputs = []
prevout_to_spend = []
@ -337,7 +334,7 @@ def invalidate_will(will,wallet,fees_per_byte):
return tx
else:
_logger.debug("balance - fee <=0")
_logger.debug(f"balance({balance}) - fee({fee}) <=0")
pass
else:
_logger.debug("len utxo_to_spend <=0")
@ -350,7 +347,7 @@ def is_new(will):
return True
def search_rai (all_inputs,all_utxos,will,wallet):
will_only_valid = only_valid_or_replaced_list(will)
will_only_valid = Will.only_valid_or_replaced_list(will)
for inp,ws in all_inputs.items():
inutxo = Util.in_utxo(inp,all_utxos)
for w in ws:
@ -370,16 +367,6 @@ def search_rai (all_inputs,all_utxos,will,wallet):
wi.set_status('CONFIRMED',True)
else:
wi.set_status('INVALIDATED',True)
#else:
# if prevout_id in will:
# wo = will[prevout_id]
# ttx= wallet.db.get_transaction(prevout_id)
# if ttx:
# _logger.error("transaction in wallet should be early detected")
# #wi.set_status('CONFIRMED',True)
# #else:
# # _logger.error("transaction not in will or utxo")
# # wi.set_status('INVALIDATED',True)
for child in wi.search(all_inputs):
if child.tx.locktime < wi.tx.locktime:
@ -396,7 +383,7 @@ def set_invalidate(wid,will=[]):
will[wid].set_status("INVALIDATED",True)
if will[wid].children:
for c in self.children.items():
set_invalidate(c[0],will)
Will.set_invalidate(c[0],will)
def check_tx_height(tx, wallet):
info=wallet.get_tx_info(tx)
@ -408,18 +395,12 @@ def check_invalidated(willtree,utxos_list,wallet):
if not w.father:
for inp in w.tx.inputs():
inp_str = Util.utxo_to_str(inp)
#print(utxos_list)
#print(inp_str)
#print(inp_str in utxos_list)
#print("notin: ",not inp_str in utxos_list)
if not inp_str in utxos_list:
#print("quindi qua non ci arrivo?")
if wallet:
height= check_tx_height(w.tx,wallet)
height= Will.check_tx_height(w.tx,wallet)
if height < 0:
#_logger.debug(f"heigth {height}")
set_invalidate(wid,willtree)
Will.set_invalidate(wid,willtree)
elif height == 0:
w.set_status("PENDING",True)
else:
@ -436,7 +417,7 @@ def reflect_to_children(treeitem):
if treeitem.get_status("REPLACED"):
wc.set_status("REPLACED",True)
if wc.children:
reflect_to_children(wc)
Will.reflect_to_children(wc)
def check_amounts(heirs,willexecutors,all_utxos,timestamp_to_check,dust):
fixed_heirs,fixed_amount,perc_heirs,perc_amount = heirs.fixed_percent_lists_amount(timestamp_to_check,dust,reverse=True)
@ -457,35 +438,32 @@ def check_amounts(heirs,willexecutors,all_utxos,timestamp_to_check,dust):
def check_will(will,all_utxos,wallet,block_to_check,timestamp_to_check):
add_willtree(will)
utxos_list= utxos_strs(all_utxos)
Will.add_willtree(will)
utxos_list= Will.utxos_strs(all_utxos)
check_invalidated(will,utxos_list,wallet)
#from pprint import pprint
#for wid,w in will.items():
# pprint(w.to_dict())
Will.check_invalidated(will,utxos_list,wallet)
all_inputs=get_all_inputs(will,only_valid = True)
all_inputs=Will.get_all_inputs(will,only_valid = True)
all_inputs_min_locktime = get_all_inputs_min_locktime(all_inputs)
all_inputs_min_locktime = Will.get_all_inputs_min_locktime(all_inputs)
check_will_expired(all_inputs_min_locktime,block_to_check,timestamp_to_check)
Will.check_will_expired(all_inputs_min_locktime,block_to_check,timestamp_to_check)
all_inputs=get_all_inputs(will,only_valid = True)
all_inputs=Will.get_all_inputs(will,only_valid = True)
search_rai(all_inputs,all_utxos,will,wallet)
Will.search_rai(all_inputs,all_utxos,will,wallet)
def is_will_valid(will, block_to_check, timestamp_to_check, tx_fees, all_utxos,heirs={},willexecutors={},self_willexecutor=False, wallet=False, callback_not_valid_tx=None):
check_will(will,all_utxos,wallet,block_to_check,timestamp_to_check)
Will.check_will(will,all_utxos,wallet,block_to_check,timestamp_to_check)
if heirs:
if not check_willexecutors_and_heirs(will,heirs,willexecutors,self_willexecutor,timestamp_to_check,tx_fees):
if not Will.check_willexecutors_and_heirs(will,heirs,willexecutors,self_willexecutor,timestamp_to_check,tx_fees):
raise NotCompleteWillException()
all_inputs=get_all_inputs(will,only_valid = True)
all_inputs=Will.get_all_inputs(will,only_valid = True)
_logger.info('check all utxo in wallet are spent')
if all_inputs:
@ -544,13 +522,12 @@ def check_willexecutors_and_heirs(will,heirs,willexecutors,self_willexecutor,che
no_willexecutor = 0
willexecutors_found = {}
heirs_found = {}
will_only_valid = only_valid_list(will)
will_only_valid = Will.only_valid_list(will)
if len(will_only_valid)<1:
return False
for wid in only_valid_list(will):
for wid in Will.only_valid_list(will):
w = will[wid]
if w.tx_fees != tx_fees:
#w.set_status('VALID',False)
raise TxFeesChangedException(f"{tx_fees}:",w.tx_fees)
for wheir in w.heirs:
if not 'w!ll3x3c"' == wheir[:9]:
@ -630,8 +607,6 @@ class WillItem(Logger):
self.STATUS['PUSH_FAIL'][1] = False
self.STATUS['CHECK_FAIL'][1] = False
#if status in ['CHECK_FAIL']:
# self.STATUS['PUSHED'][1] = False
if status in ['CHECKED']:
self.STATUS['PUSHED'][1] = True
@ -646,14 +621,14 @@ class WillItem(Logger):
if isinstance(w,WillItem,):
self.__dict__ = w.__dict__.copy()
else:
self.tx = get_tx_from_any(w['tx'])
self.tx = Will.get_tx_from_any(w['tx'])
self.heirs = w.get('heirs',None)
self.we = w.get('willexecutor',None)
self.status = w.get('status',None)
self.description = w.get('description',None)
self.time = w.get('time',None)
self.change = w.get('change',None)
self.tx_fees = w.get('tx_fees',0)
self.tx_fees = w.get('baltx_fees',0)
self.father = w.get('Father',None)
self.children = w.get('Children',None)
self.STATUS = copy.deepcopy(WillItem.STATUS_DEFAULT)
@ -683,7 +658,7 @@ class WillItem(Logger):
'description':self.description,
'time':self.time,
'change':self.change,
'tx_fees':self.tx_fees
'baltx_fees':self.tx_fees
}
for key in self.STATUS:
try:
@ -700,13 +675,11 @@ class WillItem(Logger):
return str(self.to_dict())
def set_anticipate(self, ow:'WillItem'):
nl = min(ow.tx.locktime,check_anticipate(ow,self))
nl = min(ow.tx.locktime,Will.check_anticipate(ow,self))
if int(nl) < self.tx.locktime:
#_logger.debug("actually anticipating")
self.tx.locktime = int(nl)
return True
else:
#_logger.debug("keeping the same locktime")
return False
@ -775,10 +748,11 @@ class WillItem(Logger):
else:
return "#ffffff"
class WillExpiredException(Exception):
class WillException(Exception):
pass
class NotCompleteWillException(Exception):
class WillExpiredException(WillException):
pass
class NotCompleteWillException(WillException):
pass
class HeirChangeException(NotCompleteWillException):
pass
@ -792,9 +766,9 @@ class NoWillExecutorNotPresent(NotCompleteWillException):
pass
class WillExecutorNotPresent(NotCompleteWillException):
pass
class NoHeirsException(Exception):
class NoHeirsException(WillException):
pass
class AmountException(Exception):
class AmountException(WillException):
pass
class PercAmountException(AmountException):
pass

121
willexecutors.py
View File

@ -8,40 +8,54 @@ from electrum import constants
from electrum.logging import get_logger
from electrum.gui.qt.util import WaitingDialog
from electrum.i18n import _
from .balqt.baldialog import BalWaitingDialog
from . import util as Util
from .bal import BalPlugin
from .util import Util
DEFAULT_TIMEOUT = 5
_logger = get_logger(__name__)
class Willexecutors:
def save(bal_plugin, willexecutors):
aw=bal_plugin.WILLEXECUTORS.get()
aw[constants.net.NET_NAME]=willexecutors
bal_plugin.WILLEXECUTORS.set(aw)
def get_willexecutors(bal_plugin, update = False,bal_window=False,force=False,task=True):
willexecutors = bal_plugin.config_get(bal_plugin.WILLEXECUTORS)
willexecutors = bal_plugin.WILLEXECUTORS.get()
willexecutors=willexecutors.get(constants.net.NET_NAME,{})
to_del=[]
for w in willexecutors:
initialize_willexecutor(willexecutors[w],w)
bal=bal_plugin.DEFAULT_SETTINGS[bal_plugin.WILLEXECUTORS]
if not isinstance(willexecutors[w],dict):
to_del.append(w)
continue
Willexecutors.initialize_willexecutor(willexecutors[w],w)
for w in to_del:
print("ERROR: WILLEXECUTOR TO DELETE:", w)
del willexecutors[w]
bal = bal_plugin.WILLEXECUTORS.default.get(constants.net.NET_NAME,{})
for bal_url,bal_executor in bal.items():
if not bal_url in willexecutors:
_logger.debug("replace bal")
_logger.debug(f"force add {bal_url} willexecutor")
willexecutors[bal_url] = bal_executor
if update:
found = False
for url,we in willexecutors.items():
if is_selected(we):
if Willexecutors.is_selected(we):
found = True
if found or force:
if bal_plugin.config_get(bal_plugin.PING_WILLEXECUTORS) or force:
if bal_plugin.PING_WILLEXECUTORS.get() or force:
ping_willexecutors = True
if bal_plugin.config_get(bal_plugin.ASK_PING_WILLEXECUTORS) and not force:
if bal_plugin.ASK_PING_WILLEXECUTORS.get() and not force:
if bal_window:
ping_willexecutors = bal_window.window.question(_("Contact willexecutors servers to update payment informations?"))
if ping_willexecutors:
if task:
bal_window.ping_willexecutors(willexecutors)
bal_window.ping_willexecutors(willexecutors,task)
else:
bal_window.ping_willexecutors_task(willexecutors)
return willexecutors
w_sorted = dict(sorted(willexecutors.items(), key=lambda w:w[1].get('sort',0),reverse=True))
return w_sorted
def is_selected(willexecutor,value=None):
if not willexecutor:
return False
@ -61,7 +75,7 @@ def get_willexecutor_transactions(will, force=False):
if not willitem.get_status('PUSHED') or force:
if willexecutor := willitem.we:
url=willexecutor['url']
if willexecutor and is_selected(willexecutor):
if willexecutor and Willexecutors.is_selected(willexecutor):
if not url in willexecutors:
willexecutor['txs']=""
willexecutor['txsids']=[]
@ -74,16 +88,16 @@ def get_willexecutor_transactions(will, force=False):
def only_selected_list(willexecutors):
out = {}
for url,v in willexectors.items():
if is_selected(willexecutor):
for url,v in willexecutors.items():
if Willexecutors.is_selected(willexecutor):
out[url]=v
def push_transactions_to_willexecutors(will):
willexecutors = get_transactions_to_be_pushed()
for url in willexecutors:
willexecutor = willexecutors[url]
if is_selected(willexecutor):
if Willexecutors.is_selected(willexecutor):
if 'txs' in willexecutor:
push_transactions_to_willexecutor(willexecutors[url]['txs'],url)
Willexecutors.push_transactions_to_willexecutor(willexecutors[url]['txs'],url)
def send_request(method, url, data=None, *, timeout=10):
network = Network.get_instance()
@ -91,7 +105,7 @@ def send_request(method, url, data=None, *, timeout=10):
raise ErrorConnectingServer('You are offline.')
_logger.debug(f'<-- {method} {url} {data}')
headers = {}
headers['user-agent'] = 'BalPlugin'
headers['user-agent'] = f"BalPlugin v:{BalPlugin.version()}"
headers['Content-Type']='text/plain'
try:
@ -99,13 +113,13 @@ def send_request(method, url, data=None, *, timeout=10):
response = Network.send_http_on_proxy(method, url,
params=data,
headers=headers,
on_finish=handle_response,
on_finish=Willexecutors.handle_response,
timeout=timeout)
elif method == 'post':
response = Network.send_http_on_proxy(method, url,
body=data,
headers=headers,
on_finish=handle_response,
on_finish=Willexecutors.handle_response,
timeout=timeout)
else:
raise Exception(f"unexpected {method=!r}")
@ -120,7 +134,7 @@ async def handle_response(resp:ClientResponse):
try:
r=json.loads(r)
r['status'] = resp.status
r['selected']=is_selected(willexecutor)
r['selected']=Willexecutors.is_selected(willexecutor)
r['url']=url
except:
pass
@ -131,9 +145,10 @@ class AlreadyPresentException(Exception):
def push_transactions_to_willexecutor(willexecutor):
out=True
try:
_logger.debug(f"willexecutor['txs']")
if w:=send_request('post', willexecutor['url']+"/"+constants.net.NET_NAME+"/pushtxs", data=willexecutor['txs'].encode('ascii')):
willexecutor['broadcast_stauts'] = _("Success")
if w:=Willexecutors.send_request('post', willexecutor['url']+"/"+constants.net.NET_NAME+"/pushtxs", data=willexecutor['txs'].encode('ascii')):
willexecutor['broadcast_status'] = _("Success")
_logger.debug(f"pushed: {w}")
if w !='thx':
_logger.debug(f"error: {w}")
@ -143,15 +158,15 @@ def push_transactions_to_willexecutor(willexecutor):
except Exception as e:
_logger.debug(f"error:{e}")
if str(e) == "already present":
raise AlreadyPresentException()
raise Willexecutors.AlreadyPresentException()
out=False
willexecutor['broadcast_stauts'] = _("Failed")
willexecutor['broadcast_status'] = _("Failed")
return out
def ping_servers(willexecutors):
for url,we in willexecutors.items():
get_info_task(url,we)
Willexecutors.get_info_task(url,we)
def get_info_task(url,willexecutor):
@ -159,7 +174,11 @@ def get_info_task(url,willexecutor):
try:
_logger.info("GETINFO_WILLEXECUTOR")
_logger.debug(url)
w = send_request('get',url+"/"+constants.net.NET_NAME+"/info")
netname="bitcoin"
if constants.net.NET_NAME!="mainnet":
netname=constants.net.NET_NAME
w = Willexecutors.send_request('get',url+"/"+netname+"/info")
willexecutor['url']=url
willexecutor['status'] = w['status']
willexecutor['base_fee'] = w['base_fee']
@ -178,26 +197,60 @@ def initialize_willexecutor(willexecutor,url,status=None,selected=None):
willexecutor['url']=url
if not status is None:
willexecutor['status'] = status
willexecutor['selected'] = is_selected(willexecutor,selected)
willexecutor['selected'] = Willexecutors.is_selected(willexecutor,selected)
def download_list(bal_plugin):
try:
l = Willexecutors.send_request('get',"https://welist.bitcoin-after.life/data/bitcoin?page=0&limit=100")
del l['status']
for w in l:
willexecutor=l[w]
Willexecutors.initialize_willexecutor(willexecutor,w,'New',False)
#bal_plugin.WILLEXECUTORS.set(l)
#bal_plugin.config.set_key(bal_plugin.WILLEXECUTORS,l,save=True)
return l
except Exception as e:
_logger.error(f"Failed to download willexecutors list: {e}")
return {}
def get_willexecutors_list_from_json(bal_plugin):
try:
with open("willexecutors.json") as f:
willexecutors = json.load(f)
for w in willexecutors:
willexecutor=willexecutors[w]
willexecutors.initialize_willexecutor(willexecutor,w,'New',False)
bal_plugin.config.set_key(bal_plugin.WILLEXECUTORS,willexecutors,save=True)
Willexecutors.initialize_willexecutor(willexecutor,w,'New',False)
#bal_plugin.WILLEXECUTORS.set(willexecutors)
return h
except Exception as e:
_logger.error(f"errore aprendo willexecutors.json: {e}")
_logger.error(f"error opening willexecutors json: {e}")
return {}
def check_transaction(txid,url):
_logger.debug(f"{url}:{txid}")
try:
w = send_request('post',url+"/searchtx",data=txid.encode('ascii'))
w = Willexecutors.send_request('post',url+"/searchtx",data=txid.encode('ascii'))
return w
except Exception as e:
_logger.error(f"error contacting {url} for checking txs {e}")
raise e
class WillExecutor:
def __init__(self,url,base_fee,chain,info,version):
self.url = url
self.base_fee = base_fee
self.chain = chain
self.info = info
self.version = version
def from_dict(d):
we = WillExecutor(
d['url'],
d['base_fee'],
d['chain'],
d['info'],
d['version']
)