add hold invoice cli functionality

Author: f321x

electrum/commands.py

@@ -25,6 +25,7 @@
 import io
 import sys
 import datetime
+import time
 import argparse
 import json
 import ast
@@ -60,10 +61,8 @@
 from .wallet import Abstract_Wallet, create_new_wallet, restore_wallet_from_text, Deterministic_Wallet, BumpFeeStrategy, Imported_Wallet
 from .address_synchronizer import TX_HEIGHT_LOCAL
 from .mnemonic import Mnemonic
-from .lnutil import SENT, RECEIVED
-from .lnutil import LnFeatures
 from .lntransport import extract_nodeid
-from .lnutil import channel_id_from_funding_tx
+from .lnutil import channel_id_from_funding_tx, LnFeatures, SENT, RECEIVED, MIN_FINAL_CLTV_DELTA_FOR_INVOICE
 from .plugin import run_hook, DeviceMgr, Plugins
 from .version import ELECTRUM_VERSION
 from .simple_config import SimpleConfig
@@ -995,7 +994,6 @@ async def paytomany(self, outputs, fee=None, feerate=None, from_addr=None, from_
     def get_year_timestamps(self, year:int):
         kwargs = {}
         if year:
-            import time
             start_date = datetime.datetime(year, 1, 1)
             end_date = datetime.datetime(year+1, 1, 1)
             kwargs['from_timestamp'] = time.mktime(start_date.timetuple())
@@ -1346,6 +1344,125 @@ async def add_request(self, amount, memo='', expiry=3600, lightning=False, force
         req = wallet.get_request(key)
         return wallet.export_request(req)
 
+    @command('wnl')
+    async def add_hold_invoice(
+            self,
+            payment_hash,
+            amount = None,
+            memo = "",
+            expiry = 3600,
+            min_final_cltv_expiry_delta = MIN_FINAL_CLTV_DELTA_FOR_INVOICE * 2,
+            callback_url = None,
+            wallet: Abstract_Wallet = None
+        ) -> dict:
+        """
+        Create a lightning hold invoice for the given payment hash. Hold invoices have to get settled manually later.
+        HTLCs will get failed automatically if block_height + 144 > htlc.cltv_abs.
+
+        arg:str:payment_hash:Hex encoded payment hash to be used for the invoice
+        arg:decimal:amount:Optional requested amount (in btc)
+        arg:str:memo:Optional description of the invoice
+        arg:int:expiry:Optional expiry in seconds (default: 3600s)
+        arg:int:min_final_cltv_expiry_delta:Optional min final cltv expiry delta (default: 294 blocks)
+        arg:str:callback_url:Optional callback URL for the invoice, if provided a POST request will be triggered once all htlcs arrived (doesn't use proxy)
+        """
+        assert len(payment_hash) == 64, f"Invalid payment hash length: {len(payment_hash)} != 64"
+        assert payment_hash not in wallet.lnworker.payment_info, "Payment hash already in use!"
+        assert MIN_FINAL_CLTV_DELTA_FOR_INVOICE < min_final_cltv_expiry_delta < 576, "Use a sane min_final_cltv_expiry_delta value"
+        amount = amount if amount and satoshis(amount) > 0 else None  # make amount either >0 or None
+        inbound_capacity = wallet.lnworker.num_sats_can_receive()
+        assert inbound_capacity > satoshis(amount or 0), \
+            f"Not enough inbound capacity [{inbound_capacity} sat] to receive this payment"
+        if callback_url:
+            assert callback_url.startswith("http"), "Callback URL must be http(s)://"
+
+        lnaddr, invoice = wallet.lnworker.get_bolt11_invoice(
+            payment_hash=bfh(payment_hash),
+            amount_msat=satoshis(amount) * 1000 if amount else None,
+            message=memo,
+            expiry=expiry,
+            min_final_cltv_expiry_delta=min_final_cltv_expiry_delta,
+            fallback_address=None
+        )
+        wallet.lnworker.add_payment_info_for_hold_invoice(
+            bfh(payment_hash),
+            satoshis(amount) if amount else None,
+        )
+        # ts after which the callback will not get registered anymore on restart
+        cb_expiration_ts = int(time.time()) + min_final_cltv_expiry_delta * 10 * 60 * 2
+        wallet.lnworker.register_cli_hold_invoice(payment_hash, cb_expiration_ts, callback_url)
+        result = {
+            "invoice": invoice
+        }
+        return result
+
+    @command('wnl')
+    async def settle_hold_invoice(self, preimage, wallet: Abstract_Wallet = None) -> dict:
+        """
+        Settles lightning hold invoice with 'preimage'.
+        Doesn't wait for actual settlement of the HTLCs.
+
+        arg:str:preimage:Hex encoded preimage of the payment hash
+        """
+        assert len(preimage) == 64, f"Invalid preimage length: {len(preimage)} != 64"
+        payment_hash: str = crypto.sha256(bfh(preimage)).hex()
+        assert payment_hash in wallet.lnworker.payment_info, \
+            f"Couldn't find lightning invoice for payment hash {payment_hash}"
+        assert wallet.lnworker.is_accepted_mpp(bfh(payment_hash)), \
+            f"MPP incomplete, cannot settle hold invoice with preimage {preimage}"
+        wallet.lnworker.save_preimage(bfh(payment_hash), preimage=bfh(preimage))
+        wallet.lnworker.unregister_hold_invoice(bfh(payment_hash))
+        util.trigger_callback('wallet_updated', wallet)
+        result = {
+            "settled": payment_hash
+        }
+        return result
+
+    @command('wnl')
+    async def cancel_hold_invoice(self, payment_hash, wallet: Abstract_Wallet = None) -> dict:
+        """
+        Cancels lightning hold invoice 'payment_hash'.
+
+        arg:str:payment_hash:Payment hash in hex of the hold invoice
+        """
+        assert payment_hash in wallet.lnworker.payment_info, \
+            f"Couldn't find lightning invoice for payment hash {payment_hash}"
+        assert payment_hash not in wallet.lnworker.preimages, \
+            f"Hold invoice already settled with preimage: {crypto.sha256(bfh(payment_hash)).hex()}"
+        # set to PR_UNPAID so it can get deleted
+        wallet.lnworker.set_payment_status(bfh(payment_hash), PR_UNPAID)
+        wallet.lnworker.delete_payment_info(payment_hash)
+        wallet.lnworker.unregister_hold_invoice(bfh(payment_hash))
+        result = {
+            "cancelled": payment_hash
+        }
+        return result
+
+    @command('wnl')
+    async def check_hold_invoice(self, payment_hash, wallet: Abstract_Wallet = None) -> dict:
+        """
+        Checks the status of a lightning hold invoice 'payment_hash'.
+        Possible states: unpaid, paid, settled, unknown (cancelled or not found)
+
+        arg:str:payment_hash:Payment hash in hex of the hold invoice
+        """
+        info = wallet.lnworker.get_payment_info(bfh(payment_hash))
+        amount_sat = (wallet.lnworker.get_payment_mpp_amount_msat(bfh(payment_hash)) or 0) // 1000
+        status = "unknown"
+        if info is None:
+            pass
+        elif info.status == PR_UNPAID or not wallet.lnworker.is_accepted_mpp(bfh(payment_hash)):
+            status = "unpaid"
+        elif info.status == PR_PAID and payment_hash not in wallet.lnworker.preimages:
+            status = "paid"
+        elif payment_hash in wallet.lnworker.preimages:
+            status = "settled"
+        result = {
+            "status": status,
+            "amount_sat": amount_sat
+        }
+        return result
+
     @command('w')
     async def addtransaction(self, tx, wallet: Abstract_Wallet = None):
         """

electrum/lnworker.py

@@ -62,7 +62,7 @@
     LnKeyFamily, LOCAL, REMOTE, MIN_FINAL_CLTV_DELTA_FOR_INVOICE, SENT, RECEIVED, HTLCOwner, UpdateAddHtlc, LnFeatures,
     ShortChannelID, HtlcLog, NoPathFound, InvalidGossipMsg, FeeBudgetExceeded, ImportedChannelBackupStorage,
     OnchainChannelBackupStorage, ln_compare_features, IncompatibleLightningFeatures, PaymentFeeBudget,
-    NBLOCK_CLTV_DELTA_TOO_FAR_INTO_FUTURE, GossipForwardingMessage, MIN_FUNDING_SAT
+    NBLOCK_CLTV_DELTA_TOO_FAR_INTO_FUTURE, GossipForwardingMessage, MIN_FUNDING_SAT, MIN_FINAL_CLTV_DELTA_ACCEPTED
 )
 from .lnonion import decode_onion_error, OnionFailureCode, OnionRoutingFailure, OnionPacket
 from .lnmsg import decode_msg
@@ -885,6 +885,13 @@ def __init__(self, wallet: 'Abstract_Wallet', xprv):
 
         # payment_hash -> callback:
         self.hold_invoice_callbacks = {}                # type: Dict[bytes, Callable[[bytes], Awaitable[None]]]
+        self.cli_hold_invoice_callbacks = self.db.get_dict('cli_hold_invoice_cbs')   # type: Dict[str, Tuple[Optional[str], int]]  # payment_hash -> (callback_url, expiry_ts)
+        for payment_hash, (callback_url, expiry_ts) in list(self.cli_hold_invoice_callbacks.items()):
+            if expiry_ts < time.time():
+                # delete old callbacks that are not going to get called anymore
+                del self.cli_hold_invoice_callbacks[payment_hash]
+            else:  # re-register the callback
+                self.register_cli_hold_invoice(payment_hash, expiry_ts, callback_url)
         self.payment_bundles = []                       # lists of hashes. todo:persist
 
         self.nostr_keypair = generate_keypair(BIP32Node.from_xkey(xprv), LnKeyFamily.NOSTR_KEY)
@@ -2308,15 +2315,45 @@ def get_payment_info(self, payment_hash: bytes) -> Optional[PaymentInfo]:
                 amount_msat, direction, status = self.payment_info[key]
                 return PaymentInfo(payment_hash, amount_msat, direction, status)
 
-    def add_payment_info_for_hold_invoice(self, payment_hash: bytes, lightning_amount_sat: int):
-        info = PaymentInfo(payment_hash, lightning_amount_sat * 1000, RECEIVED, PR_UNPAID)
+    def add_payment_info_for_hold_invoice(self, payment_hash: bytes, lightning_amount_sat: Optional[int]):
+        amount = lightning_amount_sat * 1000 if lightning_amount_sat else None
+        info = PaymentInfo(payment_hash, amount, RECEIVED, PR_UNPAID)
         self.save_payment_info(info, write_to_disk=False)
 
     def register_hold_invoice(self, payment_hash: bytes, cb: Callable[[bytes], Awaitable[None]]):
         self.hold_invoice_callbacks[payment_hash] = cb
 
     def unregister_hold_invoice(self, payment_hash: bytes):
         self.hold_invoice_callbacks.pop(payment_hash)
+        self.cli_hold_invoice_callbacks.pop(payment_hash.hex(), None)
+
+    def register_cli_hold_invoice(
+        self,
+        payment_hash: str,
+        expiry_ts: int,
+        callback_url: Optional[str] = None,
+    ) -> None:
+        async def cli_hold_invoice_callback(payment_hash_bytes: bytes):
+            """Hold invoice callback for hold invoices registered via CLI."""
+            self.logger.debug(f"Hold invoice {payment_hash_bytes.hex()} ready for settlement")
+            self.set_payment_status(payment_hash_bytes, PR_PAID)
+            if not callback_url:
+                return
+            amount_sat = (self.get_payment_mpp_amount_msat(payment_hash_bytes) or 0) // 1000
+            data = {
+                "payment_hash": payment_hash_bytes.hex(),
+                "amount_sat": amount_sat
+            }
+            try:
+                async with make_aiohttp_session(proxy=None) as s:
+                    await s.post(callback_url, json=data, raise_for_status=False)
+            except Exception as e:
+                self.logger.debug(f"hold invoice callback request to {callback_url} raised: {str(e)}")
+
+        self.register_hold_invoice(bfh(payment_hash), cli_hold_invoice_callback)
+        if payment_hash not in self.cli_hold_invoice_callbacks:
+            # persist the callback so it can be re-registered after restart
+            self.cli_hold_invoice_callbacks[payment_hash] = (callback_url, expiry_ts)
 
     def save_payment_info(self, info: PaymentInfo, *, write_to_disk: bool = True) -> None:
         key = info.payment_hash.hex()
@@ -2402,17 +2439,34 @@ def set_mpp_resolution(self, *, payment_key: bytes, resolution: RecvMPPResolutio
         self.received_mpp_htlcs[payment_key.hex()] = mpp_status._replace(resolution=resolution)
 
     def is_mpp_amount_reached(self, payment_key: bytes) -> bool:
-        mpp_status = self.received_mpp_htlcs.get(payment_key.hex())
-        if not mpp_status:
+        amounts = self.get_mpp_amounts(payment_key)
+        if amounts is None:
             return False
-        total = sum([_htlc.amount_msat for scid, _htlc in mpp_status.htlc_set])
-        return total >= mpp_status.expected_msat
+        total, expected = amounts
+        return total >= expected
 
     def is_accepted_mpp(self, payment_hash: bytes) -> bool:
         payment_key = self._get_payment_key(payment_hash)
         status = self.received_mpp_htlcs.get(payment_key.hex())
         return status and status.resolution == RecvMPPResolution.ACCEPTED
 
+    def get_payment_mpp_amount_msat(self, payment_hash: bytes) -> Optional[int]:
+        """Returns the received mpp amount for given payment hash."""
+        payment_key = self._get_payment_key(payment_hash)
+        amounts = self.get_mpp_amounts(payment_key)
+        if not amounts:
+            return None
+        total_msat, _ = amounts
+        return total_msat
+
+    def get_mpp_amounts(self, payment_key: bytes) -> Optional[Tuple[int, int]]:
+        """Returns (total received amount, expected amount) or None."""
+        mpp_status = self.received_mpp_htlcs.get(payment_key.hex())
+        if not mpp_status:
+            return None
+        total = sum([_htlc.amount_msat for scid, _htlc in mpp_status.htlc_set])
+        return total, mpp_status.expected_msat
+
     def get_first_timestamp_of_mpp(self, payment_key: bytes) -> int:
         mpp_status = self.received_mpp_htlcs.get(payment_key.hex())
         if not mpp_status:

tests/test_commands.py

@@ -1,6 +1,7 @@
 import unittest
 from unittest import mock
 from decimal import Decimal
+from os import urandom
 
 from electrum.commands import Commands, eval_bool
 from electrum import storage, wallet
@@ -9,6 +10,8 @@
 from electrum.simple_config import SimpleConfig
 from electrum.transaction import Transaction, TxOutput, tx_from_any
 from electrum.util import UserFacingException, NotEnoughFunds
+from electrum.crypto import sha256
+from electrum.lnaddr import lndecode
 
 from . import ElectrumTestCase
 from .test_wallet_vertical import WalletIntegrityHelper
@@ -405,3 +408,75 @@ async def test_importprivkey(self, mock_save_db):
         self.assertEqual({"good_keys": 1, "bad_keys": 2},
                          await cmds.importprivkey(privkeys2_str, wallet=wallet))
         self.assertEqual(10, len(wallet.get_addresses()))
+
+    @mock.patch.object(wallet.Abstract_Wallet, 'save_db')
+    async def test_hold_invoice_commands(self, mock_save_db):
+        wallet: Abstract_Wallet = restore_wallet_from_text(
+            'disagree rug lemon bean unaware square alone beach tennis exhibit fix mimic',
+            gap_limit=2,
+            path='if_this_exists_mocking_failed_648151893',
+            config=self.config)['wallet']
+
+        cmds = Commands(config=self.config)
+        preimage: str = sha256(urandom(32)).hex()
+        payment_hash: str = sha256(bytes.fromhex(preimage)).hex()
+        with (mock.patch.object(wallet.lnworker, 'num_sats_can_receive', return_value=1000000)):
+            result = await cmds.add_hold_invoice(
+                payment_hash=payment_hash,
+                amount=0.0001,
+                memo="test",
+                expiry=3500,
+                wallet=wallet,
+            )
+        invoice = lndecode(invoice=result['invoice'])
+        # no preimage should be generated or stored
+        assert invoice.paymenthash.hex() == payment_hash
+        assert payment_hash not in wallet.lnworker.preimages
+        # a callback should get registered
+        assert payment_hash in wallet.lnworker.cli_hold_invoice_callbacks
+        assert payment_hash in wallet.lnworker.payment_info
+        assert invoice.get_amount_sat() == 10000
+
+        cancel_result = await cmds.cancel_hold_invoice(
+            payment_hash=payment_hash,
+            wallet=wallet,
+        )
+        assert payment_hash not in wallet.lnworker.cli_hold_invoice_callbacks
+        assert payment_hash not in wallet.lnworker.payment_info
+        assert cancel_result['cancelled'] == payment_hash
+
+        with self.assertRaises(AssertionError):
+            # settling a cancelled invoice should raise
+            await cmds.settle_hold_invoice(
+                preimage=preimage,
+                wallet=wallet,
+            )
+            # cancelling an unknown invoice should raise an exception
+            await cmds.cancel_hold_invoice(
+                payment_hash=sha256(urandom(32)).hex(),
+                wallet=wallet,
+            )
+
+        # add another hold invoice
+        preimage: bytes = sha256(urandom(32))
+        payment_hash: str = sha256(preimage).hex()
+        with mock.patch.object(wallet.lnworker, 'num_sats_can_receive', return_value=1000000):
+            await cmds.add_hold_invoice(
+                payment_hash=payment_hash,
+                amount=0.0001,
+                wallet=wallet,
+            )
+
+        with mock.patch.object(wallet.lnworker, 'is_accepted_mpp', return_value=True):
+            settle_result = await cmds.settle_hold_invoice(
+                preimage=preimage.hex(),
+                wallet=wallet,
+            )
+        assert settle_result['settled'] == payment_hash
+        assert wallet.lnworker.preimages[payment_hash] == preimage.hex()
+        assert payment_hash not in wallet.lnworker.cli_hold_invoice_callbacks
+        assert bytes.fromhex(payment_hash) not in wallet.lnworker.hold_invoice_callbacks
+
+        with self.assertRaises(AssertionError):
+            # cancelling a settled invoice should raise
+            await cmds.cancel_hold_invoice(payment_hash=payment_hash, wallet=wallet)

tests/test_lnpeer.py

@@ -331,6 +331,7 @@ async def create_routes_from_invoice(self, amount_msat: int, decoded_invoice: Ln
     update_mpp_with_received_htlc = LNWallet.update_mpp_with_received_htlc
     set_mpp_resolution = LNWallet.set_mpp_resolution
     is_mpp_amount_reached = LNWallet.is_mpp_amount_reached
+    get_mpp_amounts = LNWallet.get_mpp_amounts
     get_first_timestamp_of_mpp = LNWallet.get_first_timestamp_of_mpp
     bundle_payments = LNWallet.bundle_payments
     get_payment_bundle = LNWallet.get_payment_bundle