tsubmarine swaps: create refund transaction - electrum - Electrum Bitcoin wallet
HTML git clone https://git.parazyd.org/electrum
DIR Log
DIR Files
DIR Refs
DIR Submodules
---
DIR commit 1b1c7d1f9e836acef8b8ee3db53cde12deacc756
DIR parent 756dd8eb6669af37fad90f83475b414be15a6829
HTML Author: ThomasV <thomasv@electrum.org>
Date: Fri, 22 May 2020 10:39:30 +0200
submarine swaps: create refund transaction
Diffstat:
M electrum/commands.py | 20 ++++++++++++--------
M electrum/submarine_swaps.py | 89 +++++++++++++++++++++----------
2 files changed, 73 insertions(+), 36 deletions(-)
---
DIR diff --git a/electrum/commands.py b/electrum/commands.py
t@@ -60,6 +60,7 @@ from .plugin import run_hook
from .version import ELECTRUM_VERSION
from .simple_config import SimpleConfig
from .invoices import LNInvoice
+from . import submarine_swaps
if TYPE_CHECKING:
t@@ -1102,20 +1103,23 @@ class Commands:
@command('wnp')
async def submarine_swap(self, amount, password=None, wallet: Abstract_Wallet = None):
- from .submarine_swaps import submarine_swap
- amount_sat = satoshis(amount)
- return await submarine_swap(amount_sat, wallet, self.network, password)
+ return await submarine_swaps.normal_swap(satoshis(amount), wallet, self.network, password)
@command('wn')
async def reverse_swap(self, amount, wallet: Abstract_Wallet = None):
- from .submarine_swaps import reverse_swap
- amount_sat = satoshis(amount)
- return await reverse_swap(amount_sat, wallet, self.network)
+ return await submarine_swaps.reverse_swap(satoshis(amount), wallet, self.network)
+
+ @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):
- from .submarine_swaps import claim_swap
- return await claim_swap(key, wallet)
+ 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
DIR diff --git a/electrum/submarine_swaps.py b/electrum/submarine_swaps.py
t@@ -3,11 +3,12 @@ import json
import os
from .crypto import sha256, hash_160
from .ecc import ECPrivkey
-from .bitcoin import address_to_script, script_to_p2wsh, redeem_script_to_address, opcodes
+from .bitcoin import address_to_script, script_to_p2wsh, redeem_script_to_address, opcodes, p2wsh_nested_script
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
API_URL = 'http://ecdsa.org:9001'
t@@ -49,32 +50,44 @@ WITNESS_TEMPLATE_REVERSE_SWAP = [
]
-def create_claim_tx(txin, witness_script, preimage, privkey:bytes, amount_sat, address, fee):
+def create_claim_tx(txin, witness_script, preimage, privkey:bytes, address, amount_sat, is_refund):
pubkey = ECPrivkey(privkey).get_public_key_bytes(compressed=True)
- txin.script_type = 'p2wsh'
+ print(txin.to_json())
+ if is_refund:
+ txin.script_type = 'p2wsh-p2sh'
+ txin.redeem_script = bytes.fromhex(p2wsh_nested_script(witness_script.hex()))
+ else:
+ txin.script_type = 'p2wsh'
txin.script_sig = b''
txin.pubkeys = [pubkey]
txin.num_sig = 1
txin.witness_script = witness_script
- txin._trusted_value_sats = amount_sat
- txout = PartialTxOutput(scriptpubkey=bytes.fromhex(address_to_script(address)), value=amount_sat - fee)
+ txout = PartialTxOutput(scriptpubkey=bytes.fromhex(address_to_script(address)), value=amount_sat)
tx = PartialTransaction.from_io([txin], [txout], version=2)
sig = bytes.fromhex(tx.sign_txin(0, privkey))
- witness = construct_witness([sig, preimage, witness_script])
- tx.inputs()[0].witness = bytes.fromhex(witness)
+ witness = [sig, witness_script] if is_refund else [sig, preimage, witness_script]
+ tx.inputs()[0].witness = bytes.fromhex(construct_witness(witness))
assert tx.is_complete()
return tx
@log_exceptions
-async def _claim_swap(lnworker, lockup_address, redeem_script, preimage, privkey, onchain_amount, address):
- # add address to lnwatcher
+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
for txin in list(utxos.values()):
fee = lnwatcher.config.estimate_fee(136, allow_fallback_to_static_rates=True)
- tx = create_claim_tx(txin, redeem_script, preimage, privkey, onchain_amount, address, fee)
- await lnwatcher.network.broadcast_transaction(tx)
+ amount_sat = txin._trusted_value_sats - fee
+ if amount_sat < dust_threshold():
+ print('dust')
+ continue
+ tx = create_claim_tx(txin, redeem_script, preimage, privkey, address, amount_sat, is_refund)
+ if is_refund and delta < 0:
+ print('height not reached for refund', delta, locktime)
+ print(tx.serialize())
+ else:
+ await lnwatcher.network.broadcast_transaction(tx)
@log_exceptions
t@@ -85,17 +98,33 @@ async def claim_swap(key, wallet):
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, onchain_amount, address)
+ 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 submarine_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network', password):
- #
+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)
t@@ -124,8 +153,6 @@ async def submarine_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Networ
locktime = data["timeoutBlockHeight"],
lockup_address = data["address"]
redeem_script = data["redeemScript"]
-
- print(data)
# 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)]
t@@ -135,19 +162,15 @@ async def submarine_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Networ
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
- cltv = int.from_bytes(parsed_script[6][1], byteorder='little')
- assert cltv - network.get_local_height() == 140
-
+ 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
- # todo: add callback to lnwatcher (with cltv)
- #callback = lambda: _claim_refund(lnworker, lockup_address, redeem_script, preimage, privkey, onchain_amount, address)
- #lnworker.lnwatcher.add_callback(lockup_address, callback)
-
- # pay onchain. must not be RBF
+ 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)
t@@ -183,7 +206,7 @@ async def reverse_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network'
invoice = data['invoice']
lockup_address = data['lockupAddress']
redeem_script = data['redeemScript']
- timeout_block_height = data['timeoutBlockHeight']
+ locktime = data['timeoutBlockHeight']
onchain_amount = data["onchainAmount"]
response_id = data['id']
# verify redeem_script is built with our pubkey and preimage
t@@ -194,8 +217,8 @@ async def reverse_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network'
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
- cltv = int.from_bytes(parsed_script[10][1], byteorder='little')
- assert cltv - network.get_local_height() > 10
+ 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)
t@@ -207,7 +230,7 @@ async def reverse_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network'
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, onchain_amount, address)
+ 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)
t@@ -218,3 +241,13 @@ async def reverse_swap(amount_sat, wallet: 'Abstract_Wallet', network: 'Network'
'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