610 lines
21 KiB
Python
610 lines
21 KiB
Python
import re
|
|
import json
|
|
from typing import Optional, Tuple, Dict, Any, TYPE_CHECKING,Sequence,List
|
|
|
|
import dns
|
|
import threading
|
|
import math
|
|
from dns.exception import DNSException
|
|
|
|
from electrum import bitcoin,dnssec,descriptor,constants
|
|
from electrum.util import read_json_file, write_json_file, to_string,bfh,trigger_callback
|
|
from electrum.logging import Logger, get_logger
|
|
from electrum.transaction import PartialTxInput, PartialTxOutput,TxOutpoint,PartialTransaction,TxOutput
|
|
import datetime
|
|
import urllib.request
|
|
import urllib.parse
|
|
from .bal import BalPlugin
|
|
from . import util as Util
|
|
from . import willexecutors as Willexecutors
|
|
if TYPE_CHECKING:
|
|
from .wallet_db import WalletDB
|
|
from .simple_config import SimpleConfig
|
|
|
|
|
|
_logger = get_logger(__name__)
|
|
|
|
HEIR_ADDRESS = 0
|
|
HEIR_AMOUNT = 1
|
|
HEIR_LOCKTIME = 2
|
|
HEIR_REAL_AMOUNT = 3
|
|
TRANSACTION_LABEL = "inheritance transaction"
|
|
class AliasNotFoundException(Exception):
|
|
pass
|
|
|
|
|
|
def reduce_outputs(in_amount, out_amount, fee, outputs):
|
|
if in_amount < out_amount:
|
|
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
|
|
if not network:
|
|
return 0
|
|
chain = network.blockchain()
|
|
if chain.is_tip_stale():
|
|
return 0
|
|
# figure out current block height
|
|
chain_height = chain.height() # learnt from all connected servers, SPV-checked
|
|
server_height = network.get_server_height() # height claimed by main server, unverified
|
|
# note: main server might be lagging (either is slow, is malicious, or there is an SPV-invisible-hard-fork)
|
|
# - if it's lagging too much, it is the network's job to switch away
|
|
if server_height < chain_height - 10:
|
|
# the diff is suspiciously large... give up and use something non-fingerprintable
|
|
return 0
|
|
# discourage "fee sniping"
|
|
height = min(chain_height, server_height)
|
|
return height
|
|
|
|
|
|
|
|
|
|
|
|
def prepare_transactions(locktimes, available_utxos, fees, wallet):
|
|
available_utxos=sorted(available_utxos, key=lambda x:"{}:{}:{}".format(x.value_sats(),x.prevout.txid,x.prevout.out_idx))
|
|
total_used_utxos = []
|
|
txsout={}
|
|
locktime,_=Util.get_lowest_locktimes(locktimes)
|
|
if not locktime:
|
|
return
|
|
locktime=locktime[0]
|
|
|
|
heirs = locktimes[locktime]
|
|
vero=True
|
|
while vero:
|
|
vero=False
|
|
fee=fees.get(locktime,0)
|
|
out_amount = fee
|
|
description = ""
|
|
outputs = []
|
|
paid_heirs = {}
|
|
for name,heir in heirs.items():
|
|
|
|
try:
|
|
if len(heir)>HEIR_REAL_AMOUNT:
|
|
real_amount = heir[HEIR_REAL_AMOUNT]
|
|
out_amount += real_amount
|
|
description += f"{name}\n"
|
|
paid_heirs[name]=heir
|
|
outputs.append(PartialTxOutput.from_address_and_value(heir[HEIR_ADDRESS], real_amount))
|
|
else:
|
|
pass
|
|
except Exception as e:
|
|
pass
|
|
|
|
in_amount = 0.0
|
|
used_utxos = []
|
|
try:
|
|
while utxo := available_utxos.pop():
|
|
value = utxo.value_sats()
|
|
in_amount += value
|
|
used_utxos.append(utxo)
|
|
if in_amount > out_amount:
|
|
break
|
|
|
|
except IndexError as e:
|
|
pass
|
|
if int(in_amount) < int(out_amount):
|
|
break
|
|
heirsvalue=out_amount
|
|
change = get_change_output(wallet, in_amount, out_amount, fee)
|
|
if change:
|
|
outputs.append(change)
|
|
|
|
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 = ""
|
|
tx.heirsvalue = heirsvalue
|
|
tx.set_rbf(True)
|
|
tx.remove_signatures()
|
|
txid = tx.txid()
|
|
if txid is None:
|
|
raise Exception("txid is none",tx)
|
|
|
|
tx.heirs = paid_heirs
|
|
tx.my_locktime = locktime
|
|
txsout[txid]=tx
|
|
|
|
if change:
|
|
change_idx=tx.get_output_idxs_from_address(change.address)
|
|
prevout = TxOutpoint(txid=bfh(tx.txid()), out_idx=change_idx.pop())
|
|
txin = PartialTxInput(prevout=prevout)
|
|
txin._trusted_value_sats = change.value
|
|
txin.script_descriptor = change.script_descriptor
|
|
txin.is_mine=True
|
|
txin._TxInput__address=change.address
|
|
txin._TxInput__scriptpubkey = change.scriptpubkey
|
|
txin._TxInput__value_sats = change.value
|
|
txin.utxo = tx
|
|
available_utxos.append(txin)
|
|
txsout[txid].available_utxos = available_utxos[:]
|
|
return txsout
|
|
|
|
|
|
def get_utxos_from_inputs(tx_inputs,tx,utxos):
|
|
for tx_input in tx_inputs:
|
|
prevoutstr=tx_input.prevout.to_str()
|
|
utxos[prevoutstr] =utxos.get(prevoutstr,{'input':tx_input,'txs':[]})
|
|
utxos[prevoutstr]['txs'].append(tx)
|
|
return utxos
|
|
|
|
#TODO calculate de minimum inputs to be invalidated
|
|
def invalidate_inheritance_transactions(wallet):
|
|
listids = []
|
|
utxos = {}
|
|
dtxs = {}
|
|
for k,v in wallet.get_all_labels().items():
|
|
tx = None
|
|
if TRANSACTION_LABEL == v:
|
|
tx=wallet.adb.get_transaction(k)
|
|
if tx:
|
|
dtxs[tx.txid()]=tx
|
|
get_utxos_from_inputs(tx.inputs(),tx,utxos)
|
|
|
|
for key,utxo in utxos.items():
|
|
txid=key.split(":")[0]
|
|
if txid in dtxs:
|
|
for tx in utxo['txs']:
|
|
txid =tx.txid()
|
|
del dtxs[txid]
|
|
|
|
utxos = {}
|
|
for txid,tx in dtxs.items():
|
|
get_utxos_from_inputs(tx.inputs(),tx,utxos)
|
|
|
|
utxos = sorted(utxos.items(), key = lambda item: len(item[1]))
|
|
|
|
|
|
remaining={}
|
|
invalidated = []
|
|
for key,value in utxos:
|
|
for tx in value['txs']:
|
|
txid = tx.txid()
|
|
if not txid in invalidated:
|
|
invalidated.append(tx.txid())
|
|
remaining[key] = value
|
|
|
|
def print_transaction(heirs,tx,locktimes,tx_fees):
|
|
jtx=tx.to_json()
|
|
print(f"TX: {tx.txid()}\t-\tLocktime: {jtx['locktime']}")
|
|
print(f"---")
|
|
for inp in jtx["inputs"]:
|
|
print(f"{inp['address']}: {inp['value_sats']}")
|
|
print(f"---")
|
|
for out in jtx["outputs"]:
|
|
heirname=""
|
|
for key in heirs.keys():
|
|
heir=heirs[key]
|
|
if heir[HEIR_ADDRESS] == out['address'] and str(heir[HEIR_LOCKTIME]) == str(jtx['locktime']):
|
|
heirname=key
|
|
print(f"{heirname}\t{out['address']}: {out['value_sats']}")
|
|
|
|
print()
|
|
size = tx.estimated_size()
|
|
print("fee: {}\texpected: {}\tsize: {}".format(tx.input_value()-tx.output_value(), size*tx_fees, size))
|
|
|
|
print()
|
|
try:
|
|
print(tx.serialize_to_network())
|
|
except:
|
|
print("impossible to serialize")
|
|
print()
|
|
|
|
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()
|
|
out = PartialTxOutput.from_address_and_value(change_addresses[0], change_amount)
|
|
out.is_change = True
|
|
return out
|
|
|
|
class Heirs(dict, Logger):
|
|
|
|
def __init__(self, db: 'WalletDB'):
|
|
Logger.__init__(self)
|
|
self.db = db
|
|
d = self.db.get('heirs', {})
|
|
try:
|
|
self.update(d)
|
|
except e as Exception:
|
|
return
|
|
|
|
def invalidate_transactions(self,wallet):
|
|
invalidate_inheritance_transactions(wallet)
|
|
|
|
def save(self):
|
|
self.db.put('heirs', dict(self))
|
|
|
|
def import_file(self, path):
|
|
data = read_json_file(path)
|
|
data = Heirs._validate(data)
|
|
self.update(data)
|
|
self.save()
|
|
|
|
def export_file(self, path):
|
|
write_json_file(path, self)
|
|
|
|
def __setitem__(self, key, value):
|
|
dict.__setitem__(self, key, value)
|
|
self.save()
|
|
|
|
def pop(self, key):
|
|
if key in self.keys():
|
|
res = dict.pop(self, key)
|
|
self.save()
|
|
return res
|
|
|
|
def get_locktimes(self,from_locktime, a=False):
|
|
locktimes = {}
|
|
for key in self.keys():
|
|
locktime = Util.parse_locktime_string(self[key][HEIR_LOCKTIME])
|
|
if locktime > from_locktime and not a \
|
|
or locktime <=from_locktime and a:
|
|
locktimes[int(locktime)]=None
|
|
return locktimes.keys()
|
|
|
|
def check_locktime(self):
|
|
return False
|
|
|
|
def normalize_perc(self, heir_list, total_balance, relative_balance,wallet,real=False):
|
|
amount = 0
|
|
for key,v in heir_list.items():
|
|
try:
|
|
column = HEIR_AMOUNT
|
|
if real: column = HEIR_REAL_AMOUNT
|
|
value = int(math.floor(total_balance/relative_balance*self.amount_to_float(v[column])))
|
|
if value > wallet.dust_threshold():
|
|
heir_list[key].insert(HEIR_REAL_AMOUNT, value)
|
|
amount += value
|
|
|
|
except Exception as e:
|
|
raise e
|
|
return amount
|
|
|
|
def amount_to_float(self,amount):
|
|
try:
|
|
return float(amount)
|
|
except:
|
|
try:
|
|
return float(amount[:-1])
|
|
except:
|
|
return 0.0
|
|
|
|
def fixed_percent_lists_amount(self,from_locktime,dust_threshold,reverse = False):
|
|
fixed_heirs = {}
|
|
fixed_amount = 0.0
|
|
percent_heirs= {}
|
|
percent_amount = 0.0
|
|
for key in self.keys():
|
|
try:
|
|
cmp= Util.parse_locktime_string(self[key][HEIR_LOCKTIME]) - from_locktime
|
|
if cmp<=0:
|
|
continue
|
|
if Util.is_perc(self[key][HEIR_AMOUNT]):
|
|
percent_amount += float(self[key][HEIR_AMOUNT][:-1])
|
|
percent_heirs[key] =list(self[key])
|
|
else:
|
|
heir_amount = int(math.floor(float(self[key][HEIR_AMOUNT])))
|
|
if heir_amount>dust_threshold:
|
|
fixed_amount += heir_amount
|
|
fixed_heirs[key] = list(self[key])
|
|
fixed_heirs[key].insert(HEIR_REAL_AMOUNT,heir_amount)
|
|
else:
|
|
pass
|
|
except Exception as e:
|
|
_logger.error(e)
|
|
return fixed_heirs,fixed_amount,percent_heirs,percent_amount
|
|
|
|
|
|
def prepare_lists(self, balance, total_fees, wallet, willexecutor = False, from_locktime = 0):
|
|
willexecutors_amount = 0
|
|
willexecutors = {}
|
|
heir_list = {}
|
|
onlyfixed = False
|
|
newbalance = balance - total_fees
|
|
locktimes = self.get_locktimes(from_locktime);
|
|
if willexecutor:
|
|
for locktime in locktimes:
|
|
if int(Util.int_locktime(locktime)) > int(from_locktime):
|
|
try:
|
|
base_fee = int(willexecutor['base_fee'])
|
|
willexecutors_amount += base_fee
|
|
h = [None] * 4
|
|
h[HEIR_AMOUNT] = base_fee
|
|
h[HEIR_REAL_AMOUNT] = base_fee
|
|
h[HEIR_LOCKTIME] = locktime
|
|
h[HEIR_ADDRESS] = willexecutor['address']
|
|
willexecutors["w!ll3x3c\""+willexecutor['url']+"\""+str(locktime)] = h
|
|
except Exception as e:
|
|
return [],False
|
|
else:
|
|
_logger.error(f"heir excluded from will locktime({locktime}){Util.int_locktime(locktime)}<minimum{from_locktime}"),
|
|
heir_list.update(willexecutors)
|
|
newbalance -= willexecutors_amount
|
|
fixed_heirs,fixed_amount,percent_heirs,percent_amount = self.fixed_percent_lists_amount(from_locktime,wallet.dust_threshold())
|
|
if fixed_amount > newbalance:
|
|
fixed_amount = self.normalize_perc(fixed_heirs,newbalance,fixed_amount,wallet)
|
|
onlyfixed = True
|
|
|
|
heir_list.update(fixed_heirs)
|
|
|
|
newbalance -= fixed_amount
|
|
|
|
if newbalance > 0:
|
|
perc_amount = self.normalize_perc(percent_heirs,newbalance,percent_amount,wallet)
|
|
newbalance -= perc_amount
|
|
heir_list.update(percent_heirs)
|
|
|
|
if newbalance > 0:
|
|
newbalance += fixed_amount
|
|
fixed_amount = self.normalize_perc(fixed_heirs,newbalance,fixed_amount,wallet,real=True)
|
|
newbalance -= fixed_amount
|
|
heir_list.update(fixed_heirs)
|
|
|
|
heir_list = sorted(heir_list.items(), key = lambda item: Util.parse_locktime_string(item[1][HEIR_LOCKTIME],wallet))
|
|
|
|
|
|
locktimes = {}
|
|
for key, value in heir_list:
|
|
locktime=Util.parse_locktime_string(value[HEIR_LOCKTIME])
|
|
if not locktime in locktimes: locktimes[locktime]={key:value}
|
|
else: locktimes[locktime][key]=value
|
|
return locktimes, onlyfixed
|
|
def is_perc(self,key):
|
|
return Util.is_perc(self[key][HEIR_AMOUNT])
|
|
|
|
def buildTransactions(self,bal_plugin,wallet,tx_fees = None, utxos=None,from_locktime=0):
|
|
Heirs._validate(self)
|
|
if len(self)<=0:
|
|
return
|
|
balance = 0.0
|
|
len_utxo_set = 0
|
|
available_utxos = []
|
|
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)
|
|
for utxo in utxos:
|
|
if utxo.value_sats()> 0*tx_fees:
|
|
balance += utxo.value_sats()
|
|
len_utxo_set += 1
|
|
available_utxos.append(utxo)
|
|
if len_utxo_set==0: return
|
|
j=-2
|
|
willexecutorsitems = list(willexecutors.items())
|
|
willexecutorslen = len(willexecutorsitems)
|
|
alltxs = {}
|
|
while True:
|
|
j+=1
|
|
if j >= willexecutorslen:
|
|
break
|
|
elif 0 <= j:
|
|
url, willexecutor = willexecutorsitems[j]
|
|
if not Willexecutors.is_selected(willexecutor):
|
|
continue
|
|
else:
|
|
willexecutor['url']=url
|
|
elif j == -1:
|
|
if not no_willexecutors:
|
|
continue
|
|
url = willexecutor = False
|
|
else:
|
|
break
|
|
fees = {}
|
|
i=0
|
|
while True:
|
|
txs = {}
|
|
redo = False
|
|
i+=1
|
|
total_fees=0
|
|
for fee in fees:
|
|
total_fees += int(fees[fee])
|
|
newbalance = balance
|
|
locktimes, onlyfixed = self.prepare_lists(balance, total_fees, wallet, willexecutor, from_locktime)
|
|
try:
|
|
txs = prepare_transactions(locktimes, available_utxos[:], fees, wallet)
|
|
if not txs:
|
|
return {}
|
|
except Exception as e:
|
|
try:
|
|
if "w!ll3x3c" in e.heirname:
|
|
Willexecutors.is_selected(willexecutors[w],False)
|
|
break
|
|
except:
|
|
raise e
|
|
total_fees = 0
|
|
total_fees_real = 0
|
|
total_in = 0
|
|
for txid,tx in txs.items():
|
|
tx.willexecutor = willexecutor
|
|
fee = tx.estimated_size() * tx_fees
|
|
txs[txid].tx_fees= tx_fees
|
|
total_fees += fee
|
|
total_fees_real += tx.get_fee()
|
|
total_in += tx.input_value()
|
|
rfee= tx.input_value()-tx.output_value()
|
|
if rfee < fee or rfee > fee + wallet.dust_threshold():
|
|
redo = True
|
|
oldfees= fees.get(tx.my_locktime,0)
|
|
fees[tx.my_locktime]=fee
|
|
|
|
|
|
if balance - total_in > wallet.dust_threshold():
|
|
redo = True
|
|
if not redo:
|
|
break
|
|
if i>=10:
|
|
break
|
|
alltxs.update(txs)
|
|
|
|
return alltxs
|
|
def get_transactions(self,bal_plugin,wallet,tx_fees,utxos=None,from_locktime=0):
|
|
txs=self.buildTransactions(bal_plugin,wallet,tx_fees,utxos,from_locktime)
|
|
if txs:
|
|
temp_txs = {}
|
|
for txid in txs:
|
|
if txs[txid].available_utxos:
|
|
temp_txs.update(self.get_transactions(bal_plugin,wallet,tx_fees,txs[txid].available_utxos,txs[txid].locktime))
|
|
txs.update(temp_txs)
|
|
return txs
|
|
|
|
|
|
|
|
def resolve(self, k):
|
|
if bitcoin.is_address(k):
|
|
return {
|
|
'address': k,
|
|
'type': 'address'
|
|
}
|
|
if k in self.keys():
|
|
_type, addr = self[k]
|
|
if _type == 'address':
|
|
return {
|
|
'address': addr,
|
|
'type': 'heir'
|
|
}
|
|
if openalias := self.resolve_openalias(k):
|
|
return openalias
|
|
raise AliasNotFoundException("Invalid Bitcoin address or alias", k)
|
|
|
|
@classmethod
|
|
def resolve_openalias(cls, url: str) -> Dict[str, Any]:
|
|
out = cls._resolve_openalias(url)
|
|
if out:
|
|
address, name, validated = out
|
|
return {
|
|
'address': address,
|
|
'name': name,
|
|
'type': 'openalias',
|
|
'validated': validated
|
|
}
|
|
return {}
|
|
|
|
def by_name(self, name):
|
|
for k in self.keys():
|
|
_type, addr = self[k]
|
|
if addr.casefold() == name.casefold():
|
|
return {
|
|
'name': addr,
|
|
'type': _type,
|
|
'address': k
|
|
}
|
|
return None
|
|
|
|
def fetch_openalias(self, config: 'SimpleConfig'):
|
|
self.alias_info = None
|
|
alias = config.OPENALIAS_ID
|
|
if alias:
|
|
alias = str(alias)
|
|
def f():
|
|
self.alias_info = self._resolve_openalias(alias)
|
|
trigger_callback('alias_received')
|
|
t = threading.Thread(target=f)
|
|
t.daemon = True
|
|
t.start()
|
|
|
|
@classmethod
|
|
def _resolve_openalias(cls, url: str) -> Optional[Tuple[str, str, bool]]:
|
|
# support email-style addresses, per the OA standard
|
|
url = url.replace('@', '.')
|
|
try:
|
|
records, validated = dnssec.query(url, dns.rdatatype.TXT)
|
|
except DNSException as e:
|
|
_logger.info(f'Error resolving openalias: {repr(e)}')
|
|
return None
|
|
prefix = 'btc'
|
|
for record in records:
|
|
string = to_string(record.strings[0], 'utf8')
|
|
if string.startswith('oa1:' + prefix):
|
|
address = cls.find_regex(string, r'recipient_address=([A-Za-z0-9]+)')
|
|
name = cls.find_regex(string, r'recipient_name=([^;]+)')
|
|
if not name:
|
|
name = address
|
|
if not address:
|
|
continue
|
|
return address, name, validated
|
|
|
|
@staticmethod
|
|
def find_regex(haystack, needle):
|
|
regex = re.compile(needle)
|
|
try:
|
|
return regex.search(haystack).groups()[0]
|
|
except AttributeError:
|
|
return None
|
|
|
|
|
|
def validate_address(address):
|
|
if not bitcoin.is_address(address):
|
|
raise NotAnAddress(f"not an address,{address}")
|
|
return address
|
|
|
|
def validate_amount(amount):
|
|
try:
|
|
if Util.is_perc(amount):
|
|
famount = float(amount[:-1])
|
|
else:
|
|
famount = float(amount)
|
|
if famount <= 0.00000001:
|
|
raise AmountNotValid(f"amount have to be positive {famount} < 0")
|
|
except Exception as e:
|
|
raise AmountNotValid(f"amount not properly formatted, {e}")
|
|
return amount
|
|
|
|
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:
|
|
raise HeirExpiredException()
|
|
except Exception as e:
|
|
raise LocktimeNotValid(f"locktime string not properly formatted, {e}")
|
|
return locktime
|
|
|
|
def validate_heir(k,v,timestamp_to_check=False):
|
|
address = Heirs.validate_address(v[HEIR_ADDRESS])
|
|
amount = Heirs.validate_amount(v[HEIR_AMOUNT])
|
|
locktime = Heirs.validate_locktime(v[HEIR_LOCKTIME],timestamp_to_check)
|
|
return (address,amount,locktime)
|
|
|
|
def _validate(data,timestamp_to_check=False):
|
|
for k, v in list(data.items()):
|
|
if k == 'heirs':
|
|
return Heirs._validate(v)
|
|
try:
|
|
Heirs.validate_heir(k,v)
|
|
except Exception as e:
|
|
data.pop(k)
|
|
return data
|
|
|
|
class NotAnAddress(ValueError):
|
|
pass
|
|
class AmountNotValid(ValueError):
|
|
pass
|
|
class LocktimeNotValid(ValueError):
|
|
pass
|
|
class HeirExpiredException(LocktimeNotValid):
|
|
pass
|