lukechilds
/
electrum
mirror of https://github.com/lukechilds/electrum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

submarine_swaps: add SwapManager

bip39-recovery
ThomasV 5 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
Split 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
View File

@ -1103,23 +1103,12 @@ class Commands:
@command('wnp')
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')
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:
if x == 'false': return False

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

@ -16,7 +16,6 @@ from .util import (MyTreeView, WindowModalDialog, Buttons, OkButton, CancelButto
from .amountedit import BTCAmountEdit, FreezableLineEdit
from electrum import submarine_swaps as ss
import asyncio
from .util import read_QIcon
@ -26,6 +25,7 @@ class SwapDialog(WindowModalDialog):
def __init__(self, window):
WindowModalDialog.__init__(self, window, _('Submarine Swap'))
self.window = window
self.swap_manager = self.window.wallet.lnworker.swap_manager
self.network = window.network
self.normal_fee = 0
self.lockup_fee = 0
@ -85,7 +85,7 @@ class SwapDialog(WindowModalDialog):
self.send_amount_e.follows = False
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()
print(pairs)
fees = pairs['pairs']['BTC/BTC']['fees']
@ -125,9 +125,9 @@ class SwapDialog(WindowModalDialog):
return
if self.is_reverse:
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:
amount_sat = self.recv_amount_e.get_amount()
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)

2
electrum/lnworker.py
View File

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

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

Write Preview
Loading…
Cancel
Save