download welist
This commit is contained in:
parent
e542c82ee1
commit
4d021e1d82
14
bal.py
14
bal.py
@ -1,15 +1,10 @@
|
||||
import random
|
||||
import os
|
||||
from hashlib import sha256
|
||||
from typing import NamedTuple, Optional, Dict, Tuple
|
||||
|
||||
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
|
||||
json_db.register_dict('heirs', tuple, None)
|
||||
json_db.register_dict('will', lambda x: get_will(x), None)
|
||||
@ -17,11 +12,10 @@ json_db.register_dict('will_settings', lambda x:x, None)
|
||||
from electrum.logging import get_logger
|
||||
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
|
||||
@ -69,7 +63,7 @@ class BalPlugin(BasePlugin):
|
||||
HIDE_INVALIDATED:True,
|
||||
ALLOW_REPUSH: False,
|
||||
WILLEXECUTORS: {
|
||||
'http://bitcoin-after.life:9137': {
|
||||
'https://bitcoin-after.life:9137': {
|
||||
"base_fee": 100000,
|
||||
"status": "New",
|
||||
"info":"Bitcoin After Life Will Executor",
|
||||
@ -102,10 +96,8 @@ class BalPlugin(BasePlugin):
|
||||
|
||||
def config_get(self,key):
|
||||
v = self.config.get(key,None)
|
||||
print("config get",key,v)
|
||||
if v is None:
|
||||
self.config.set_key(key,self.DEFAULT_SETTINGS[key])
|
||||
print("config setkey",key)
|
||||
v = self.DEFAULT_SETTINGS[key]
|
||||
return v
|
||||
|
||||
|
||||
7
heirs.py
7
heirs.py
@ -15,8 +15,8 @@ import datetime
|
||||
import urllib.request
|
||||
import urllib.parse
|
||||
from .bal import BalPlugin
|
||||
from . import util as Util
|
||||
from . import willexecutors as Willexecutors
|
||||
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
|
||||
|
||||
"""
|
||||
|
||||
|
||||
|
||||
|
||||
@ -3,5 +3,6 @@
|
||||
"fullname": "Bitcoin After Life",
|
||||
"description": "Provides free and decentralized inheritance support",
|
||||
"author":"Svātantrya",
|
||||
"available_for": ["qt"]
|
||||
"available_for": ["qt"],
|
||||
"icon":"icons/bal32x32.png"
|
||||
}
|
||||
|
||||
173
util.py
173
util.py
@ -8,7 +8,8 @@ import urllib.parse
|
||||
from electrum.util import write_json_file,FileImportFailed,FileExportFailed
|
||||
|
||||
LOCKTIME_THRESHOLD = 500000000
|
||||
def locktime_to_str(locktime):
|
||||
class Util:
|
||||
def locktime_to_str(locktime):
|
||||
try:
|
||||
locktime=int(locktime)
|
||||
if locktime > LOCKTIME_THRESHOLD:
|
||||
@ -16,29 +17,26 @@ def locktime_to_str(locktime):
|
||||
return dt
|
||||
|
||||
except Exception as e:
|
||||
#print(e)
|
||||
pass
|
||||
return str(locktime)
|
||||
|
||||
def str_to_locktime(locktime):
|
||||
def str_to_locktime(locktime):
|
||||
try:
|
||||
if locktime[-1] in ('y','d','b'):
|
||||
return locktime
|
||||
else: return int(locktime)
|
||||
except Exception as e:
|
||||
pass
|
||||
#print(e)
|
||||
dt_object = datetime.fromisoformat(locktime)
|
||||
timestamp = dt_object.timestamp()
|
||||
return int(timestamp)
|
||||
|
||||
def parse_locktime_string(locktime,w=None):
|
||||
def parse_locktime_string(locktime,w=None):
|
||||
try:
|
||||
return int(locktime)
|
||||
|
||||
except Exception as e:
|
||||
pass
|
||||
#print("parse_locktime_string",e)
|
||||
try:
|
||||
now = datetime.now()
|
||||
if locktime[-1] == 'y':
|
||||
@ -49,20 +47,19 @@ 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
|
||||
|
||||
|
||||
def int_locktime(seconds=0,minutes=0,hours=0, days=0, blocks = 0):
|
||||
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):
|
||||
def encode_amount(amount, decimal_point):
|
||||
if Util.is_perc(amount):
|
||||
return amount
|
||||
else:
|
||||
try:
|
||||
@ -70,21 +67,21 @@ def encode_amount(amount, decimal_point):
|
||||
except:
|
||||
return 0
|
||||
|
||||
def decode_amount(amount,decimal_point):
|
||||
if is_perc(amount):
|
||||
def decode_amount(amount,decimal_point):
|
||||
if Util.is_perc(amount):
|
||||
return amount
|
||||
else:
|
||||
num=8-decimal_point
|
||||
basestr="{{:0{}.{}f}}".format(num,num)
|
||||
return "{:08.8f}".format(float(amount)/pow(10,decimal_point))
|
||||
|
||||
def is_perc(value):
|
||||
def is_perc(value):
|
||||
try:
|
||||
return value[-1] == '%'
|
||||
except:
|
||||
return False
|
||||
|
||||
def cmp_array(heira,heirb):
|
||||
def cmp_array(heira,heirb):
|
||||
try:
|
||||
if not len(heira) == len(heirb):
|
||||
return False
|
||||
@ -95,12 +92,12 @@ def cmp_array(heira,heirb):
|
||||
except:
|
||||
return False
|
||||
|
||||
def cmp_heir(heira,heirb):
|
||||
def cmp_heir(heira,heirb):
|
||||
if heira[0] == heirb[0] and heira[1] == heirb[1]:
|
||||
return True
|
||||
return False
|
||||
|
||||
def cmp_willexecutor(willexecutora,willexecutorb):
|
||||
def cmp_willexecutor(willexecutora,willexecutorb):
|
||||
if willexecutora == willexecutorb:
|
||||
return True
|
||||
try:
|
||||
@ -110,8 +107,7 @@ def cmp_willexecutor(willexecutora,willexecutorb):
|
||||
return False
|
||||
return False
|
||||
|
||||
def search_heir_by_values(heirs,heir,values):
|
||||
#print()
|
||||
def search_heir_by_values(heirs,heir,values):
|
||||
for h,v in heirs.items():
|
||||
found = False
|
||||
for val in values:
|
||||
@ -122,98 +118,86 @@ def search_heir_by_values(heirs,heir,values):
|
||||
return h
|
||||
return False
|
||||
|
||||
def cmp_heir_by_values(heira,heirb,values):
|
||||
def cmp_heir_by_values(heira,heirb,values):
|
||||
for v in values:
|
||||
if heira[v] != heirb[v]:
|
||||
return False
|
||||
return True
|
||||
|
||||
def cmp_heirs_by_values(heirsa,heirsb,values,exclude_willexecutors=False,reverse = True):
|
||||
def cmp_heirs_by_values(heirsa,heirsb,values,exclude_willexecutors=False,reverse = True):
|
||||
for heira in heirsa:
|
||||
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
|
||||
|
||||
def cmp_heirs(heirsa,heirsb,cmp_function = lambda x,y: x[0]==y[0] and x[3]==y[3],reverse=True):
|
||||
def cmp_heirs(heirsa,heirsb,cmp_function = lambda x,y: x[0]==y[0] and x[3]==y[3],reverse=True):
|
||||
try:
|
||||
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:
|
||||
raise e
|
||||
return False
|
||||
|
||||
def cmp_inputs(inputsa,inputsb):
|
||||
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
|
||||
|
||||
def cmp_outputs(outputsa,outputsb,willexecutor_output = None):
|
||||
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()):
|
||||
def cmp_txs(txa,txb):
|
||||
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
|
||||
|
||||
def get_value_amount(txa,txb):
|
||||
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
|
||||
|
||||
|
||||
|
||||
def chk_locktime(timestamp_to_check,block_height_to_check,locktime):
|
||||
def chk_locktime(timestamp_to_check,block_height_to_check,locktime):
|
||||
#TODO BUG: WHAT HAPPEN AT THRESHOLD?
|
||||
locktime=int(locktime)
|
||||
if locktime > LOCKTIME_THRESHOLD and locktime > timestamp_to_check:
|
||||
@ -223,7 +207,7 @@ def chk_locktime(timestamp_to_check,block_height_to_check,locktime):
|
||||
else:
|
||||
return False
|
||||
|
||||
def anticipate_locktime(locktime,blocks=0,hours=0,days=0):
|
||||
def anticipate_locktime(locktime,blocks=0,hours=0,days=0):
|
||||
locktime = int(locktime)
|
||||
out=0
|
||||
if locktime> LOCKTIME_THRESHOLD:
|
||||
@ -239,13 +223,13 @@ def anticipate_locktime(locktime,blocks=0,hours=0,days=0):
|
||||
out = 1
|
||||
return out
|
||||
|
||||
def cmp_locktime(locktimea,locktimeb):
|
||||
def cmp_locktime(locktimea,locktimeb):
|
||||
if 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])
|
||||
@ -253,23 +237,22 @@ def cmp_locktime(locktimea,locktimeb):
|
||||
return int(locktimea)-(locktimeb)
|
||||
|
||||
|
||||
def get_lowest_valid_tx(available_utxos,will):
|
||||
def get_lowest_valid_tx(available_utxos,will):
|
||||
will = sorted(will.items(),key = lambda x: x[1]['tx'].locktime)
|
||||
for txid,willitem in will.items():
|
||||
pass
|
||||
|
||||
def get_locktimes(will):
|
||||
def get_locktimes(will):
|
||||
locktimes = {}
|
||||
for txid,willitem in will.items():
|
||||
locktimes[willitem['tx'].locktime]=True
|
||||
return locktimes.keys()
|
||||
|
||||
def get_lowest_locktimes(locktimes):
|
||||
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:
|
||||
@ -277,86 +260,83 @@ 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))
|
||||
def get_lowest_locktimes_from_will(will):
|
||||
return Util.get_lowest_locktimes(Util.get_locktimes(will))
|
||||
|
||||
def search_willtx_per_io(will,tx):
|
||||
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
|
||||
|
||||
def invalidate_will(will):
|
||||
def invalidate_will(will):
|
||||
raise Exception("not implemented")
|
||||
|
||||
def get_will_spent_utxos(will):
|
||||
def get_will_spent_utxos(will):
|
||||
utxos=[]
|
||||
for txid,willitem in will.items():
|
||||
utxos+=willitem['tx'].inputs()
|
||||
|
||||
return utxos
|
||||
|
||||
def utxo_to_str(utxo):
|
||||
def utxo_to_str(utxo):
|
||||
try: return utxo.to_str()
|
||||
except Exception as e: pass
|
||||
try: return utxo.prevout.to_str()
|
||||
except Exception as e: pass
|
||||
return str(utxo)
|
||||
|
||||
def cmp_utxo(utxoa,utxob):
|
||||
utxoa=utxo_to_str(utxoa)
|
||||
utxob=utxo_to_str(utxob)
|
||||
def cmp_utxo(utxoa,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):
|
||||
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
|
||||
|
||||
def txid_in_utxo(txid,utxos):
|
||||
def txid_in_utxo(txid,utxos):
|
||||
for s_u in utxos:
|
||||
if s_u.prevout.txid == txid:
|
||||
return True
|
||||
return False
|
||||
|
||||
def cmp_output(outputa,outputb):
|
||||
def cmp_output(outputa,outputb):
|
||||
return outputa.address == outputb.address and outputa.value == outputb.value
|
||||
|
||||
def in_output(output,outputs):
|
||||
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
|
||||
|
||||
#check all output with the same amount if none have the same address it can be a change
|
||||
#return true true same address same amount
|
||||
#return true false same amount different address
|
||||
#return false false different amount, different address not found
|
||||
#check all output with the same amount if none have the same address it can be a change
|
||||
#return true true same address same amount
|
||||
#return true false same amount different address
|
||||
#return false false different amount, different address not found
|
||||
|
||||
|
||||
def din_output(out,outputs):
|
||||
def din_output(out,outputs):
|
||||
same_amount=[]
|
||||
for s_o in 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
|
||||
else:return False, False
|
||||
|
||||
|
||||
def get_change_output(wallet,in_amount,out_amount,fee):
|
||||
def get_change_output(wallet,in_amount,out_amount,fee):
|
||||
change_amount = int(in_amount - out_amount - fee)
|
||||
if change_amount > wallet.dust_threshold():
|
||||
change_addresses = wallet.get_change_addresses_for_new_transaction()
|
||||
@ -365,7 +345,7 @@ def get_change_output(wallet,in_amount,out_amount,fee):
|
||||
return out
|
||||
|
||||
|
||||
def get_current_height(network:'Network'):
|
||||
def get_current_height(network:'Network'):
|
||||
#if no network or not up to date, just set locktime to zero
|
||||
if not network:
|
||||
return 0
|
||||
@ -385,7 +365,7 @@ def get_current_height(network:'Network'):
|
||||
return height
|
||||
|
||||
|
||||
def print_var(var,name = "",veryverbose=False):
|
||||
def print_var(var,name = "",veryverbose=False):
|
||||
print(f"---{name}---")
|
||||
if not var is None:
|
||||
try:
|
||||
@ -415,25 +395,24 @@ def print_var(var,name = "",veryverbose=False):
|
||||
|
||||
print(f"---end {name}---")
|
||||
|
||||
def print_utxo(utxo, name = ""):
|
||||
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)
|
||||
print(f"---utxo-end {name}---")
|
||||
|
||||
def print_prevout(prevout, 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):
|
||||
def export_meta_gui(electrum_window: 'ElectrumWindow', title, exporter):
|
||||
filter_ = "All files (*)"
|
||||
filename = getSaveFileName(
|
||||
parent=electrum_window,
|
||||
@ -453,6 +432,6 @@ def export_meta_gui(electrum_window: 'ElectrumWindow', title, exporter):
|
||||
.format(title, str(filename)))
|
||||
|
||||
|
||||
def copy(dicto,dictfrom):
|
||||
def copy(dicto,dictfrom):
|
||||
for k,v in dictfrom.items():
|
||||
dicto[k]=v
|
||||
|
||||
184
will.py
184
will.py
@ -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 _
|
||||
|
||||
@ -16,7 +16,8 @@ MIN_BLOCK = 1
|
||||
_logger = get_logger(__name__)
|
||||
|
||||
#return an array with the list of children
|
||||
def get_children(will,willid):
|
||||
class Will:
|
||||
def get_children(will,willid):
|
||||
out = []
|
||||
for _id in will:
|
||||
inputs = will[_id].tx.inputs()
|
||||
@ -26,26 +27,26 @@ def get_children(will,willid):
|
||||
out.append([_id,idi,_input.prevout.out_idx])
|
||||
return out
|
||||
|
||||
#build a tree with parent transactions
|
||||
def add_willtree(will):
|
||||
#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
|
||||
|
||||
|
||||
#return a list of will sorted by locktime
|
||||
def get_sorted_will(will):
|
||||
#return a list of will sorted by locktime
|
||||
def get_sorted_will(will):
|
||||
return sorted(will.items(),key = lambda x: x[1]['tx'].locktime)
|
||||
|
||||
|
||||
def only_valid(will):
|
||||
def only_valid(will):
|
||||
for k,v in will.items():
|
||||
if v.get_status('VALID'):
|
||||
yield k
|
||||
|
||||
def search_equal_tx(will,tx,wid):
|
||||
def search_equal_tx(will,tx,wid):
|
||||
for w in will:
|
||||
if w != wid and not tx.to_json() != will[w]['tx'].to_json():
|
||||
if will[w]['tx'].txid() != tx.txid():
|
||||
@ -53,7 +54,7 @@ def search_equal_tx(will,tx,wid):
|
||||
return will[w]['tx']
|
||||
return False
|
||||
|
||||
def get_tx_from_any(x):
|
||||
def get_tx_from_any(x):
|
||||
try:
|
||||
a=str(x)
|
||||
return tx_from_any(a)
|
||||
@ -63,9 +64,9 @@ def get_tx_from_any(x):
|
||||
|
||||
return x
|
||||
|
||||
def add_info_from_will(will,wid,wallet):
|
||||
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():
|
||||
@ -83,12 +84,12 @@ def add_info_from_will(will,wid,wallet):
|
||||
txin._TxInput__value_sats = change.value
|
||||
txin._trusted_value_sats = change.value
|
||||
|
||||
def normalize_will(will,wallet = None,others_inputs = {}):
|
||||
def normalize_will(will,wallet = None,others_inputs = {}):
|
||||
to_delete = []
|
||||
to_add = {}
|
||||
#add info from wallet
|
||||
for wid in will:
|
||||
add_info_from_will(will,wid,wallet)
|
||||
Will.add_info_from_will(will,wid,wallet)
|
||||
errors ={}
|
||||
for wid in will:
|
||||
|
||||
@ -112,7 +113,7 @@ def normalize_will(will,wallet = None,others_inputs = {}):
|
||||
will[wid]=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()
|
||||
@ -127,7 +128,7 @@ def normalize_will(will,wallet = None,others_inputs = {}):
|
||||
if wid in will:
|
||||
del will[wid]
|
||||
|
||||
def new_input(txid,idx,change):
|
||||
def new_input(txid,idx,change):
|
||||
prevout = TxOutpoint(txid=bfh(txid), out_idx=idx)
|
||||
inp = PartialTxInput(prevout=prevout)
|
||||
inp._trusted_value_sats = change.value
|
||||
@ -137,27 +138,20 @@ def new_input(txid,idx,change):
|
||||
inp._TxInput__value_sats = change.value
|
||||
return inp
|
||||
|
||||
def check_anticipate(ow:'WillItem',nw:'WillItem'):
|
||||
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:
|
||||
@ -172,7 +166,7 @@ def check_anticipate(ow:'WillItem',nw:'WillItem'):
|
||||
return 4294967295+1
|
||||
|
||||
|
||||
def change_input(will, otxid, idx, change,others_inputs,to_delete,to_append):
|
||||
def change_input(will, otxid, idx, change,others_inputs,to_delete,to_append):
|
||||
ow = will[otxid]
|
||||
ntxid = ow.tx.txid()
|
||||
if otxid != ntxid:
|
||||
@ -188,7 +182,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,9 +193,9 @@ 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):
|
||||
def get_all_inputs(will,only_valid = False):
|
||||
all_inputs = {}
|
||||
for w,wi in will.items():
|
||||
if not only_valid or wi.get_status('VALID'):
|
||||
@ -215,7 +209,7 @@ def get_all_inputs(will,only_valid = False):
|
||||
all_inputs[prevout_str].append(inp)
|
||||
return all_inputs
|
||||
|
||||
def get_all_inputs_min_locktime(all_inputs):
|
||||
def get_all_inputs_min_locktime(all_inputs):
|
||||
all_inputs_min_locktime = {}
|
||||
|
||||
for i,values in all_inputs.items():
|
||||
@ -230,11 +224,11 @@ def get_all_inputs_min_locktime(all_inputs):
|
||||
return all_inputs_min_locktime
|
||||
|
||||
|
||||
def search_anticipate_rec(will,old_inputs):
|
||||
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 +237,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 +248,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)
|
||||
def update_will(old_will,new_will):
|
||||
all_old_inputs = Will.get_all_inputs(old_will,only_valid=True)
|
||||
all_inputs_min_locktime = Will.get_all_inputs_min_locktime(all_old_inputs)
|
||||
all_new_inputs = Will.get_all_inputs(new_will)
|
||||
#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,14 +274,12 @@ 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):
|
||||
def get_higher_input_for_tx(will):
|
||||
out = {}
|
||||
for wid in will:
|
||||
wtx = will[wid].tx
|
||||
@ -300,9 +292,9 @@ def get_higher_input_for_tx(will):
|
||||
out[inp.prevout.to_str()] = inp
|
||||
return out
|
||||
|
||||
def invalidate_will(will,wallet,fees_per_byte):
|
||||
will_only_valid = only_valid_list(will)
|
||||
inputs = get_all_inputs(will_only_valid)
|
||||
def invalidate_will(will,wallet,fees_per_byte):
|
||||
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 = []
|
||||
@ -344,13 +336,13 @@ def invalidate_will(will,wallet,fees_per_byte):
|
||||
pass
|
||||
|
||||
|
||||
def is_new(will):
|
||||
def is_new(will):
|
||||
for wid,w in will.items():
|
||||
if w.get_status('VALID') and not w.get_status('COMPLETE'):
|
||||
return True
|
||||
|
||||
def search_rai (all_inputs,all_utxos,will,wallet):
|
||||
will_only_valid = only_valid_or_replaced_list(will)
|
||||
def search_rai (all_inputs,all_utxos,will,wallet):
|
||||
will_only_valid = Will.only_valid_or_replaced_list(will)
|
||||
for inp,ws in all_inputs.items():
|
||||
inutxo = Util.in_utxo(inp,all_utxos)
|
||||
for w in ws:
|
||||
@ -370,16 +362,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:
|
||||
@ -388,44 +370,38 @@ def search_rai (all_inputs,all_utxos,will,wallet):
|
||||
else:
|
||||
pass
|
||||
|
||||
def utxos_strs(utxos):
|
||||
def utxos_strs(utxos):
|
||||
return [Util.utxo_to_str(u) for u in utxos]
|
||||
|
||||
|
||||
def set_invalidate(wid,will=[]):
|
||||
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):
|
||||
def check_tx_height(tx, wallet):
|
||||
info=wallet.get_tx_info(tx)
|
||||
return info.tx_mined_status.height
|
||||
|
||||
#check if transactions are stil valid tecnically valid
|
||||
def check_invalidated(willtree,utxos_list,wallet):
|
||||
#check if transactions are stil valid tecnically valid
|
||||
def check_invalidated(willtree,utxos_list,wallet):
|
||||
for wid,w in willtree.items():
|
||||
if not w.father:
|
||||
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:
|
||||
w.set_status('CONFIRMED',True)
|
||||
|
||||
def reflect_to_children(treeitem):
|
||||
def reflect_to_children(treeitem):
|
||||
if not treeitem.get_status("VALID"):
|
||||
_logger.debug(f"{tree:item._id} status not valid looking for children")
|
||||
for child in treeitem.children:
|
||||
@ -436,9 +412,9 @@ 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):
|
||||
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)
|
||||
wallet_balance = 0
|
||||
for utxo in all_utxos:
|
||||
@ -456,36 +432,33 @@ def check_amounts(heirs,willexecutors,all_utxos,timestamp_to_check,dust):
|
||||
raise FixedAmountException(f"Willexecutor{url} excess base fee({wex['base_fee']}), {fixed_amount} >={temp_balance}")
|
||||
|
||||
|
||||
def check_will(will,all_utxos,wallet,block_to_check,timestamp_to_check):
|
||||
add_willtree(will)
|
||||
utxos_list= utxos_strs(all_utxos)
|
||||
def check_will(will,all_utxos,wallet,block_to_check,timestamp_to_check):
|
||||
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):
|
||||
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:
|
||||
@ -499,7 +472,7 @@ def is_will_valid(will, block_to_check, timestamp_to_check, tx_fees, all_utxos,h
|
||||
_logger.info('will ok')
|
||||
return True
|
||||
|
||||
def check_will_expired(all_inputs_min_locktime,block_to_check,timestamp_to_check):
|
||||
def check_will_expired(all_inputs_min_locktime,block_to_check,timestamp_to_check):
|
||||
_logger.info("check if some transaction is expired")
|
||||
for prevout_str, wid in all_inputs_min_locktime.items():
|
||||
for w in wid:
|
||||
@ -512,7 +485,7 @@ def check_will_expired(all_inputs_min_locktime,block_to_check,timestamp_to_check
|
||||
if locktime < int(timestamp_to_check):
|
||||
raise WillExpiredException(f"Will Expired {wid[0][0]}: {locktime}<{timestamp_to_check}")
|
||||
|
||||
def check_all_input_spent_are_in_wallet():
|
||||
def check_all_input_spent_are_in_wallet():
|
||||
_logger.info("check all input spent are in wallet or valid txs")
|
||||
for inp,ws in all_inputs.items():
|
||||
if not Util.in_utxo(inp,all_utxos):
|
||||
@ -524,14 +497,14 @@ def check_all_input_spent_are_in_wallet():
|
||||
w[1].set_status('INVALIDATED',True)
|
||||
|
||||
|
||||
def only_valid_list(will):
|
||||
def only_valid_list(will):
|
||||
out={}
|
||||
for wid,w in will.items():
|
||||
if w.get_status('VALID'):
|
||||
out[wid]=w
|
||||
return out
|
||||
|
||||
def only_valid_or_replaced_list(will):
|
||||
def only_valid_or_replaced_list(will):
|
||||
out=[]
|
||||
for wid,w in will.items():
|
||||
wi = w
|
||||
@ -539,18 +512,17 @@ def only_valid_or_replaced_list(will):
|
||||
out.append(wid)
|
||||
return out
|
||||
|
||||
def check_willexecutors_and_heirs(will,heirs,willexecutors,self_willexecutor,check_date,tx_fees):
|
||||
def check_willexecutors_and_heirs(will,heirs,willexecutors,self_willexecutor,check_date,tx_fees):
|
||||
_logger.debug("check willexecutors heirs")
|
||||
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 +602,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,7 +616,7 @@ 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)
|
||||
@ -700,13 +670,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
|
||||
|
||||
|
||||
|
||||
@ -9,16 +9,15 @@ 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 .util import Util
|
||||
|
||||
DEFAULT_TIMEOUT = 5
|
||||
_logger = get_logger(__name__)
|
||||
|
||||
def get_willexecutors(bal_plugin, update = False,bal_window=False,force=False,task=True):
|
||||
class Willexecutors:
|
||||
def get_willexecutors(bal_plugin, update = False,bal_window=False,force=False,task=True):
|
||||
willexecutors = bal_plugin.config_get(bal_plugin.WILLEXECUTORS)
|
||||
for w in willexecutors:
|
||||
initialize_willexecutor(willexecutors[w],w)
|
||||
Willexecutors.initialize_willexecutor(willexecutors[w],w)
|
||||
|
||||
bal=bal_plugin.DEFAULT_SETTINGS[bal_plugin.WILLEXECUTORS]
|
||||
for bal_url,bal_executor in bal.items():
|
||||
@ -28,7 +27,7 @@ def get_willexecutors(bal_plugin, update = False,bal_window=False,force=False,ta
|
||||
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:
|
||||
@ -42,7 +41,7 @@ def get_willexecutors(bal_plugin, update = False,bal_window=False,force=False,ta
|
||||
bal_window.ping_willexecutors_task(willexecutors)
|
||||
return willexecutors
|
||||
|
||||
def is_selected(willexecutor,value=None):
|
||||
def is_selected(willexecutor,value=None):
|
||||
if not willexecutor:
|
||||
return False
|
||||
if not value is None:
|
||||
@ -53,7 +52,7 @@ def is_selected(willexecutor,value=None):
|
||||
willexecutor['selected']=False
|
||||
return False
|
||||
|
||||
def get_willexecutor_transactions(will, force=False):
|
||||
def get_willexecutor_transactions(will, force=False):
|
||||
willexecutors ={}
|
||||
for wid,willitem in will.items():
|
||||
if willitem.get_status('VALID'):
|
||||
@ -61,7 +60,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']=[]
|
||||
@ -72,20 +71,20 @@ def get_willexecutor_transactions(will, force=False):
|
||||
|
||||
return willexecutors
|
||||
|
||||
def only_selected_list(willexecutors):
|
||||
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):
|
||||
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):
|
||||
def send_request(method, url, data=None, *, timeout=10):
|
||||
network = Network.get_instance()
|
||||
if not network:
|
||||
raise ErrorConnectingServer('You are offline.')
|
||||
@ -99,13 +98,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}")
|
||||
@ -115,24 +114,25 @@ def send_request(method, url, data=None, *, timeout=10):
|
||||
else:
|
||||
_logger.debug(f'--> {response}')
|
||||
return response
|
||||
async def handle_response(resp:ClientResponse):
|
||||
async def handle_response(resp:ClientResponse):
|
||||
r=await resp.text()
|
||||
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
|
||||
return r
|
||||
|
||||
class AlreadyPresentException(Exception):
|
||||
class AlreadyPresentException(Exception):
|
||||
pass
|
||||
def push_transactions_to_willexecutor(willexecutor):
|
||||
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')):
|
||||
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':
|
||||
@ -143,23 +143,26 @@ 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_status'] = _("Failed")
|
||||
|
||||
return out
|
||||
|
||||
def ping_servers(willexecutors):
|
||||
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):
|
||||
def get_info_task(url,willexecutor):
|
||||
w=None
|
||||
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']
|
||||
@ -174,29 +177,45 @@ def get_info_task(url,willexecutor):
|
||||
willexecutor['last_update'] = datetime.now().timestamp()
|
||||
return willexecutor
|
||||
|
||||
def initialize_willexecutor(willexecutor,url,status=None,selected=None):
|
||||
def initialize_willexecutor(willexecutor,url,status=None,selected=None):
|
||||
print("1",willexecutor)
|
||||
willexecutor['url']=url
|
||||
print("2",status)
|
||||
if not status is None:
|
||||
willexecutor['status'] = status
|
||||
willexecutor['selected'] = is_selected(willexecutor,selected)
|
||||
|
||||
def get_willexecutors_list_from_json(bal_plugin):
|
||||
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']
|
||||
from pprint import pprint
|
||||
pprint(l)
|
||||
for w in l:
|
||||
print("----")
|
||||
willexecutor=l[w]
|
||||
Willexecutors.initialize_willexecutor(willexecutor,w,'New',False)
|
||||
bal_plugin.config.set_key(bal_plugin.WILLEXECUTORS,l,save=True)
|
||||
return l
|
||||
except Exception as e:
|
||||
_logger.error(f"error downloading 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)
|
||||
Willexecutors.initialize_willexecutor(willexecutor,w,'New',False)
|
||||
bal_plugin.config.set_key(bal_plugin.WILLEXECUTORS,willexecutors,save=True)
|
||||
return h
|
||||
except Exception as e:
|
||||
_logger.error(f"errore aprendo willexecutors.json: {e}")
|
||||
return {}
|
||||
|
||||
def check_transaction(txid,url):
|
||||
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}")
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user