zebra.lucky
/
electrum
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

submarine_swaps: add SwapManager

master
ThomasV 6 years ago
parent
b26ad81e69
commit
17ff6ffa08
4 changed files with 175 additions and 197 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      electrum/commands.py
  2. 8
      electrum/gui/qt/swap_dialog.py
  3. 2
      electrum/lnworker.py
  4. 347
      electrum/submarine_swaps.py

15
electrum/commands.py
Unescape View File

@ -1103,23 +1103,12 @@ class Commands:
@command('wnp') @command('wnp')
async def submarine_swap(self, amount, password=None, wallet: Abstract_Wallet = None): async def submarine_swap(self, amount, password=None, wallet: Abstract_Wallet = None):
return await submarine_swaps.normal_swap(satoshis(amount), wallet, self.network, password) return await wallet.lnworker.swap_manager.normal_swap(satoshis(amount), password)
@command('wn') @command('wn')
async def reverse_swap(self, amount, wallet: Abstract_Wallet = None): async def reverse_swap(self, amount, wallet: Abstract_Wallet = None):
return await submarine_swaps.reverse_swap(satoshis(amount), wallet, self.network) return await wallet.lnworker.swap_manager.reverse_swap(satoshis(amount))
@command('n')
async def get_pairs(self):
return await submarine_swaps.get_pairs(self.network)
@command('wn')
async def claim_swap(self, key, wallet: Abstract_Wallet = None):
return await submarine_swaps.claim_swap(key, wallet)
@command('wn')
async def refund_swap(self, key, wallet: Abstract_Wallet = None):
return await submarine_swaps.refund_swap(key, wallet)
def eval_bool(x: str) -> bool: def eval_bool(x: str) -> bool:
if x == 'false': return False if x == 'false': return False

8
electrum/gui/qt/swap_dialog.py
Unescape View File

@ -16,7 +16,6 @@ from .util import (MyTreeView, WindowModalDialog, Buttons, OkButton, CancelButto
from .amountedit import BTCAmountEdit, FreezableLineEdit from .amountedit import BTCAmountEdit, FreezableLineEdit
from electrum import submarine_swaps as ss
import asyncio import asyncio
from .util import read_QIcon from .util import read_QIcon
@ -26,6 +25,7 @@ class SwapDialog(WindowModalDialog):
def __init__(self, window): def __init__(self, window):
WindowModalDialog.__init__(self, window, _('Submarine Swap')) WindowModalDialog.__init__(self, window, _('Submarine Swap'))
self.window = window self.window = window
self.swap_manager = self.window.wallet.lnworker.swap_manager
self.network = window.network self.network = window.network
self.normal_fee = 0 self.normal_fee = 0
self.lockup_fee = 0 self.lockup_fee = 0
@ -85,7 +85,7 @@ class SwapDialog(WindowModalDialog):
self.send_amount_e.follows = False self.send_amount_e.follows = False
def get_pairs(self): def get_pairs(self):
fut = asyncio.run_coroutine_threadsafe(ss.get_pairs(self.network), self.network.asyncio_loop) fut = asyncio.run_coroutine_threadsafe(self.swap_manager.get_pairs(), self.network.asyncio_loop)
pairs = fut.result() pairs = fut.result()
print(pairs) print(pairs)
fees = pairs['pairs']['BTC/BTC']['fees'] fees = pairs['pairs']['BTC/BTC']['fees']
@ -125,9 +125,9 @@ class SwapDialog(WindowModalDialog):
return return
if self.is_reverse: if self.is_reverse:
amount_sat = self.send_amount_e.get_amount() amount_sat = self.send_amount_e.get_amount()
coro = ss.reverse_swap(amount_sat, self.window.wallet, self.network) coro = self.swap_manager.reverse_swap(amount_sat)
else: else:
amount_sat = self.recv_amount_e.get_amount() amount_sat = self.recv_amount_e.get_amount()
password = self.window.protect(lambda x: x, []) password = self.window.protect(lambda x: x, [])
coro = ss.normal_swap(amount_sat, self.window.wallet, self.network, password) coro = self.swap_manager.normal_swap(amount_sat, password)
asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop) asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)

2
electrum/lnworker.py
Unescape View File

@ -70,6 +70,7 @@ from .crypto import pw_encode_bytes, pw_decode_bytes, PW_HASH_VERSION_LATEST
from .lnutil import ChannelBackupStorage from .lnutil import ChannelBackupStorage
from .lnchannel import ChannelBackup from .lnchannel import ChannelBackup
from .channel_db import UpdateStatus from .channel_db import UpdateStatus
from .submarine_swaps import SwapManager
if TYPE_CHECKING: if TYPE_CHECKING:
from .network import Network from .network import Network
@ -556,6 +557,7 @@ class LNWallet(LNWorker):
self.lnwatcher = LNWalletWatcher(self, network) self.lnwatcher = LNWalletWatcher(self, network)
self.lnwatcher.start_network(network) self.lnwatcher.start_network(network)
self.network = network self.network = network
self.swap_manager = SwapManager(self.wallet, network)
for chan in self.channels.values(): for chan in self.channels.values():
self.lnwatcher.add_channel(chan.funding_outpoint.to_str(), chan.get_funding_address()) self.lnwatcher.add_channel(chan.funding_outpoint.to_str(), chan.get_funding_address())

347
electrum/submarine_swaps.py
Unescape View File

@ -6,10 +6,10 @@ from .ecc import ECPrivkey
from .bitcoin import address_to_script, script_to_p2wsh, redeem_script_to_address, opcodes, p2wsh_nested_script, push_script, is_segwit_address from .bitcoin import address_to_script, script_to_p2wsh, redeem_script_to_address, opcodes, p2wsh_nested_script, push_script, is_segwit_address
from .transaction import TxOutpoint, PartialTxInput, PartialTxOutput, PartialTransaction, construct_witness from .transaction import TxOutpoint, PartialTxInput, PartialTxOutput, PartialTransaction, construct_witness
from .transaction import script_GetOp, match_script_against_template, OPPushDataGeneric, OPPushDataPubkey from .transaction import script_GetOp, match_script_against_template, OPPushDataGeneric, OPPushDataPubkey
from .transaction import Transaction
from .util import log_exceptions from .util import log_exceptions
from .bitcoin import dust_threshold from .bitcoin import dust_threshold
from typing import TYPE_CHECKING from typing import TYPE_CHECKING
from .logging import Logger
if TYPE_CHECKING: if TYPE_CHECKING:
from .network import Network from .network import Network
@ -73,182 +73,169 @@ def create_claim_tx(txin, witness_script, preimage, privkey:bytes, address, amou
return tx return tx
@log_exceptions
async def _claim_swap(lnworker, lockup_address, redeem_script, preimage, privkey, address, locktime, is_refund=False): class SwapManager(Logger):
lnwatcher = lnworker.lnwatcher
utxos = lnwatcher.get_addr_utxo(lockup_address) @log_exceptions
delta = lnwatcher.network.get_local_height() - locktime async def _claim_swap(self, lockup_address, redeem_script, preimage, privkey, locktime, is_refund=False):
if is_refund and delta < 0: utxos = self.lnwatcher.get_addr_utxo(lockup_address)
print('height not reached for refund', delta, locktime) if not utxos:
return return
for txin in list(utxos.values()): delta = self.network.get_local_height() - locktime
fee = lnwatcher.config.estimate_fee(136, allow_fallback_to_static_rates=True) if is_refund and delta < 0:
amount_sat = txin._trusted_value_sats - fee self.logger.info(f'height not reached for refund {lockup_address} {delta}, {locktime}')
if amount_sat < dust_threshold(): return
print('txo lower than dust threshold') for txin in list(utxos.values()):
continue fee = self.lnwatcher.config.estimate_fee(136, allow_fallback_to_static_rates=True)
tx = create_claim_tx(txin, redeem_script, preimage, privkey, address, amount_sat, locktime, is_refund) amount_sat = txin._trusted_value_sats - fee
await lnwatcher.network.broadcast_transaction(tx) if amount_sat < dust_threshold():
self.logger.info('utxo value below dust threshold')
continue
@log_exceptions address = self.wallet.get_unused_address()
async def claim_swap(key, wallet): tx = create_claim_tx(txin, redeem_script, preimage, privkey, address, amount_sat, locktime, is_refund)
lnworker = wallet.lnworker await self.network.broadcast_transaction(tx)
address = wallet.get_unused_address()
swaps = wallet.db.get_dict('submarine_swaps') def __init__(self, wallet: 'Abstract_Wallet', network:'Network'):
data = swaps[key] Logger.__init__(self)
onchain_amount = data['onchainAmount'] self.network = network
redeem_script = bytes.fromhex(data['redeemScript']) self.wallet = wallet
locktime = data['timeoutBlockHeight'] self.lnworker = wallet.lnworker
lockup_address = data['lockupAddress'] self.lnwatcher = self.wallet.lnworker.lnwatcher
preimage = bytes.fromhex(data['preimage']) swaps = self.wallet.db.get_dict('submarine_swaps')
privkey = bytes.fromhex(data['privkey']) for key, data in swaps.items():
callback = lambda: _claim_swap(lnworker, lockup_address, redeem_script, preimage, privkey, address, locktime, is_refund=False) redeem_script = bytes.fromhex(data['redeemScript'])
lnworker.lnwatcher.add_callback(lockup_address, callback) locktime = data['timeoutBlockHeight']
return True preimage = bytes.fromhex(data['preimage'])
privkey = bytes.fromhex(data['privkey'])
if data.get('invoice'):
@log_exceptions lockup_address = data['lockupAddress']
async def refund_swap(key, wallet): is_refund = False
lnworker = wallet.lnworker else:
address = wallet.get_unused_address() lockup_address = data['address']
swaps = wallet.db.get_dict('submarine_swaps') is_refund = True
data = swaps[key] self.add_lnwatcher_callback(lockup_address, redeem_script, preimage, privkey, locktime, is_refund)
lockup_address = data['address']
redeem_script = bytes.fromhex(data['redeemScript']) def add_lnwatcher_callback(self, lockup_address, redeem_script, preimage, privkey, locktime, is_refund):
locktime = data['timeoutBlockHeight'] callback = lambda: self._claim_swap(lockup_address, redeem_script, preimage, privkey, locktime, is_refund=is_refund)
preimage = bytes.fromhex(data['preimage']) self.lnwatcher.add_callback(lockup_address, callback)
privkey = bytes.fromhex(data['privkey'])
callback = lambda: _claim_swap(lnworker, lockup_address, redeem_script, preimage, privkey, address, locktime, is_refund=True) @log_exceptions
lnworker.lnwatcher.add_callback(lockup_address, callback) async def normal_swap(self, amount_sat, password):
return True privkey = os.urandom(32)
pubkey = ECPrivkey(privkey).get_public_key_bytes(compressed=True)
key = await self.lnworker._add_request_coro(amount_sat, 'swap', expiry=3600*24)
@log_exceptions request = self.wallet.get_request(key)
async def normal_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network', password): invoice = request['invoice']
lnworker = wallet.lnworker lnaddr = self.lnworker._check_invoice(invoice, amount_sat)
privkey = os.urandom(32) payment_hash = lnaddr.paymenthash
pubkey = ECPrivkey(privkey).get_public_key_bytes(compressed=True) preimage = self.lnworker.get_preimage(payment_hash)
key = await lnworker._add_request_coro(amount_sat, 'swap', expiry=3600*24) request_data = {
request = wallet.get_request(key) "type": "submarine",
invoice = request['invoice'] "pairId": "BTC/BTC",
lnaddr = lnworker._check_invoice(invoice, amount_sat) "orderSide": "sell",
payment_hash = lnaddr.paymenthash "invoice": invoice,
preimage = lnworker.get_preimage(payment_hash) "refundPublicKey": pubkey.hex()
address = wallet.get_unused_address() }
request_data = { response = await self.network._send_http_on_proxy(
"type": "submarine", 'post',
"pairId": "BTC/BTC", API_URL + '/createswap',
"orderSide": "sell", json=request_data,
"invoice": invoice, timeout=30)
"refundPublicKey": pubkey.hex() data = json.loads(response)
} response_id = data["id"]
response = await network._send_http_on_proxy( zeroconf = data["acceptZeroConf"]
'post', onchain_amount = data["expectedAmount"]
API_URL + '/createswap', locktime = data["timeoutBlockHeight"]
json=request_data, lockup_address = data["address"]
timeout=30) redeem_script = data["redeemScript"]
data = json.loads(response) # verify redeem_script is built with our pubkey and preimage
response_id = data["id"] redeem_script = bytes.fromhex(redeem_script)
zeroconf = data["acceptZeroConf"] parsed_script = [x for x in script_GetOp(redeem_script)]
onchain_amount = data["expectedAmount"] assert match_script_against_template(redeem_script, WITNESS_TEMPLATE_SWAP)
locktime = data["timeoutBlockHeight"] assert script_to_p2wsh(redeem_script.hex()) == lockup_address
lockup_address = data["address"] assert hash_160(preimage) == parsed_script[1][1]
redeem_script = data["redeemScript"] assert pubkey == parsed_script[9][1]
# verify redeem_script is built with our pubkey and preimage # verify that they are not locking up funds for more than a day
redeem_script = bytes.fromhex(redeem_script) assert locktime == int.from_bytes(parsed_script[6][1], byteorder='little')
parsed_script = [x for x in script_GetOp(redeem_script)] assert locktime - self.network.get_local_height() < 144
assert match_script_against_template(redeem_script, WITNESS_TEMPLATE_SWAP) # save swap data in wallet in case we need a refund
assert script_to_p2wsh(redeem_script.hex()) == lockup_address data['privkey'] = privkey.hex()
assert hash_160(preimage) == parsed_script[1][1] data['preimage'] = preimage.hex()
assert pubkey == parsed_script[9][1] swaps = self.wallet.db.get_dict('submarine_swaps')
# verify that we will have enought time to get our tx confirmed swaps[response_id] = data
assert locktime == int.from_bytes(parsed_script[6][1], byteorder='little') self.add_lnwatcher_callback(lockup_address, redeem_script, preimage, privkey, locktime, is_refund=True)
assert locktime - network.get_local_height() == 140 outputs = [PartialTxOutput.from_address_and_value(lockup_address, onchain_amount)]
# save swap data in wallet in case we need a refund tx = self.wallet.create_transaction(outputs=outputs, rbf=False, password=password)
data['privkey'] = privkey.hex() await self.network.broadcast_transaction(tx)
data['preimage'] = preimage.hex() #
swaps = wallet.db.get_dict('submarine_swaps') attempt = await self.lnworker.await_payment(payment_hash)
swaps[response_id] = data return {
callback = lambda: _claim_swap(lnworker, lockup_address, redeem_script, preimage, privkey, address, locktime, is_refund=True) 'id':response_id,
lnworker.lnwatcher.add_callback(lockup_address, callback) 'success':attempt.success,
outputs = [PartialTxOutput.from_address_and_value(lockup_address, onchain_amount)] }
tx = wallet.create_transaction(outputs=outputs, rbf=False, password=password)
await network.broadcast_transaction(tx) @log_exceptions
# async def reverse_swap(self, amount_sat):
attempt = await lnworker.await_payment(payment_hash) privkey = os.urandom(32)
return { pubkey = ECPrivkey(privkey).get_public_key_bytes(compressed=True)
'id':response_id, preimage = os.urandom(32)
'success':attempt.success, preimage_hash = sha256(preimage)
} request_data = {
"type": "reversesubmarine",
"pairId": "BTC/BTC",
@log_exceptions "orderSide": "buy",
async def reverse_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network'): "invoiceAmount": amount_sat,
privkey = os.urandom(32) "preimageHash": preimage_hash.hex(),
pubkey = ECPrivkey(privkey).get_public_key_bytes(compressed=True) "claimPublicKey": pubkey.hex()
preimage = os.urandom(32) }
preimage_hash = sha256(preimage) response = await self.network._send_http_on_proxy(
address = wallet.get_unused_address() 'post',
request_data = { API_URL + '/createswap',
"type": "reversesubmarine", json=request_data,
"pairId": "BTC/BTC", timeout=30)
"orderSide": "buy", data = json.loads(response)
"invoiceAmount": amount_sat, invoice = data['invoice']
"preimageHash": preimage_hash.hex(), lockup_address = data['lockupAddress']
"claimPublicKey": pubkey.hex() redeem_script = data['redeemScript']
} locktime = data['timeoutBlockHeight']
response = await network._send_http_on_proxy( onchain_amount = data["onchainAmount"]
'post', response_id = data['id']
API_URL + '/createswap', # verify redeem_script is built with our pubkey and preimage
json=request_data, redeem_script = bytes.fromhex(redeem_script)
timeout=30) parsed_script = [x for x in script_GetOp(redeem_script)]
data = json.loads(response) assert match_script_against_template(redeem_script, WITNESS_TEMPLATE_REVERSE_SWAP)
invoice = data['invoice'] assert script_to_p2wsh(redeem_script.hex()) == lockup_address
lockup_address = data['lockupAddress'] assert hash_160(preimage) == parsed_script[5][1]
redeem_script = data['redeemScript'] assert pubkey == parsed_script[7][1]
locktime = data['timeoutBlockHeight'] # verify that we will have enought time to get our tx confirmed
onchain_amount = data["onchainAmount"] assert locktime == int.from_bytes(parsed_script[10][1], byteorder='little')
response_id = data['id'] assert locktime - self.network.get_local_height() > 10
# verify redeem_script is built with our pubkey and preimage # verify invoice preimage_hash
redeem_script = bytes.fromhex(redeem_script) lnaddr = self.lnworker._check_invoice(invoice, amount_sat)
parsed_script = [x for x in script_GetOp(redeem_script)] assert lnaddr.paymenthash == preimage_hash
assert match_script_against_template(redeem_script, WITNESS_TEMPLATE_REVERSE_SWAP) # save swap data in wallet in case payment fails
assert script_to_p2wsh(redeem_script.hex()) == lockup_address data['privkey'] = privkey.hex()
assert hash_160(preimage) == parsed_script[5][1] data['preimage'] = preimage.hex()
assert pubkey == parsed_script[7][1] # save data to wallet file
# verify that we will have enought time to get our tx confirmed swaps = self.wallet.db.get_dict('submarine_swaps')
assert locktime == int.from_bytes(parsed_script[10][1], byteorder='little') swaps[response_id] = data
assert locktime - network.get_local_height() > 10 # add callback to lnwatcher
# verify invoice preimage_hash self.add_lnwatcher_callback(lockup_address, redeem_script, preimage, privkey, locktime, is_refund=False)
lnworker = wallet.lnworker # initiate payment.
lnaddr = lnworker._check_invoice(invoice, amount_sat) success, log = await self.lnworker._pay(invoice, attempts=5)
assert lnaddr.paymenthash == preimage_hash # discard data; this should be done by lnwatcher
# save swap data in wallet in case payment fails if success:
data['privkey'] = privkey.hex() swaps.pop(response_id)
data['preimage'] = preimage.hex() return {
# save data to wallet file 'id':response_id,
swaps = wallet.db.get_dict('submarine_swaps') 'success':success,
swaps[response_id] = data }
# add callback to lnwatcher
callback = lambda: _claim_swap(lnworker, lockup_address, redeem_script, preimage, privkey, address, locktime, is_refund=False) @log_exceptions
lnworker.lnwatcher.add_callback(lockup_address, callback) async def get_pairs(self):
# initiate payment. response = await self.network._send_http_on_proxy(
success, log = await lnworker._pay(invoice, attempts=5) 'get',
# discard data; this should be done by lnwatcher API_URL + '/getpairs',
if success: timeout=30)
swaps.pop(response_id) data = json.loads(response)
return { return data
'id':response_id,
'success':success,
}
@log_exceptions
async def get_pairs(network):
response = await network._send_http_on_proxy(
'get',
API_URL + '/getpairs',
timeout=30)
data = json.loads(response)
return data

Write Preview
Loading…
Cancel
Save