refactor payment_identifier

# Conflicts:
#	electrum/gui/qt/send_tab.py

Author: kratm2

electrum/gui/qt/send_tab.py

@@ -246,7 +246,8 @@ def spend_max(self):
         if pi is None or pi.type == PaymentIdentifierType.UNKNOWN:
             return
         elif pi.type not in [PaymentIdentifierType.SPK, PaymentIdentifierType.MULTILINE,
-                           PaymentIdentifierType.BIP21, PaymentIdentifierType.OPENALIAS]:
+                             PaymentIdentifierType.SILENT_PAYMENT,
+                             PaymentIdentifierType.BIP21, PaymentIdentifierType.OPENALIAS]:
             # clear the amount field once it is clear this PI is not eligible for '!'
             self.amount_e.clear()
             return
@@ -454,14 +455,15 @@ def update_fields(self):
                                      PaymentIdentifierType.OPENALIAS, PaymentIdentifierType.BIP70,
                                      PaymentIdentifierType.BIP21, PaymentIdentifierType.BOLT11] and not pi.need_resolve()
         lock_amount = pi.is_amount_locked()
-        lock_max = lock_amount or pi.type not in [PaymentIdentifierType.SPK, PaymentIdentifierType.BIP21]
+        lock_max = lock_amount or pi.type not in [PaymentIdentifierType.SPK, PaymentIdentifierType.BIP21,
+                                                  PaymentIdentifierType.SILENT_PAYMENT]
 
         self.lock_fields(lock_recipient=lock_recipient,
                          lock_amount=lock_amount,
                          lock_max=lock_max,
                          lock_description=False)
         if lock_recipient:
-            fields = pi.get_fields_for_GUI(bip21_prefer_fallback=not self.wallet_can_send_sp)
+            fields = pi.get_fields_for_GUI()
             if fields.recipient:
                 self.payto_e.setText(fields.recipient)
             if fields.description:

electrum/payment_identifier.py

@@ -85,6 +85,7 @@ class PaymentIdentifierType(IntEnum):
     OPENALIAS = 8
     LNADDR = 9
     DOMAINLIKE = 10
+    SILENT_PAYMENT = 11
 
 
 class FieldsForGUI(NamedTuple):
@@ -138,6 +139,8 @@ def __init__(self, wallet: Optional['Abstract_Wallet'], text: str):
         #
         self.lnurl = None
         self.lnurl_data = None
+        #
+        self.sp_address = None # used when a single silent payment is identified
 
         self.parse(text)
 
@@ -173,7 +176,7 @@ def is_lightning(self):
 
     def is_onchain(self):
         if self._type in [PaymentIdentifierType.SPK, PaymentIdentifierType.MULTILINE, PaymentIdentifierType.BIP70,
-                          PaymentIdentifierType.OPENALIAS]:
+                          PaymentIdentifierType.OPENALIAS, PaymentIdentifierType.SILENT_PAYMENT]:
             return True
         if self._type in [PaymentIdentifierType.LNURLP, PaymentIdentifierType.BOLT11, PaymentIdentifierType.LNADDR]:
             return bool(self.bolt11) and bool(self.bolt11.get_address())
@@ -275,12 +278,23 @@ def parse(self, text: str):
                     # no address, no bolt11 and no silent payment address, invalid
                     self.set_state(PaymentIdentifierState.INVALID)
                     return
+                elif self.bip21.get('address') == DummyAddress.SILENT_PAYMENT:
+                    self.set_state(PaymentIdentifierState.INVALID)
+                    return # user manually entered DummyAddress.SILENT_PAYMENT
                 self.set_state(PaymentIdentifierState.AVAILABLE)
         elif self.parse_output(text)[0]:
             scriptpubkey, is_address = self.parse_output(text)
-            self._type = PaymentIdentifierType.SPK
-            self.spk = scriptpubkey
-            self.spk_is_address = is_address
+            if bitcoin.script_to_address(scriptpubkey) == DummyAddress.SILENT_PAYMENT:
+                sp_address = self.parse_address(text)
+                if sp_address == DummyAddress.SILENT_PAYMENT:
+                    self.set_state(PaymentIdentifierState.INVALID) # user manually entered DummyAddress.SILENT_PAYMENT
+                    return
+                self.sp_address = sp_address
+                self._type = PaymentIdentifierType.SILENT_PAYMENT
+            else:
+                self._type = PaymentIdentifierType.SPK
+                self.spk = scriptpubkey
+                self.spk_is_address = is_address
             self.set_state(PaymentIdentifierState.AVAILABLE)
         elif self.contacts and (contact := self.contacts.by_name(text)):
             if contact['type'] in ('address', 'sp_address'):
@@ -468,23 +482,18 @@ async def _do_notify_merchant(
             if on_finished:
                 on_finished(self)
 
-    def get_onchain_outputs(self, amount, bip21_use_fallback=False):
+    def get_onchain_outputs(self, amount, allow_silent_payment=True):
         if self.bip70:
             return self.bip70_data.get_outputs()
         elif self.multiline_outputs:
             return self.multiline_outputs
         elif self.spk:
-            output = PartialTxOutput(scriptpubkey=self.spk, value=amount)
-            if output.address == DummyAddress.SILENT_PAYMENT:
-                sp_addr = self.parse_address(self.text) # parse again if e.g. a contact was entered
-                output.sp_addr = SilentPaymentAddress(sp_addr)
-            return [output]
+            return [PartialTxOutput(scriptpubkey=self.spk, value=amount)]
         elif self.bip21:
             address = self.bip21.get('address') # fallback address if sp_address is present
-            sp_address = self.bip21.get(constants.net.BIP352_HRP)
 
-            if sp_address:
-                if bip21_use_fallback:
+            if sp_address := self.bip21.get(constants.net.BIP352_HRP):
+                if not allow_silent_payment:
                     if not address:
                         raise MissingFallbackAddress('requested BIP21 fallback address but none was provided.')
                     # fallback is requested and present, keep using `address`
@@ -497,6 +506,10 @@ def get_onchain_outputs(self, amount, bip21_use_fallback=False):
             if output.address == DummyAddress.SILENT_PAYMENT:
                 output.sp_addr = SilentPaymentAddress(address)
             return [output]
+        elif self.sp_address:
+            output = PartialTxOutput.from_address_and_value(address=DummyAddress.SILENT_PAYMENT, value=amount)
+            output.sp_addr = SilentPaymentAddress(self.sp_address)
+            return [output]
         else:
             raise Exception('not onchain')
 
@@ -595,7 +608,7 @@ def _get_error_from_invoiceerror(self, e: 'InvoiceError') -> str:
                 error = _("Invoice requires unknown or incompatible Lightning feature") + f":\n{e!r}"
         return error
 
-    def get_fields_for_GUI(self, *, bip21_prefer_fallback=False) -> FieldsForGUI:
+    def get_fields_for_GUI(self) -> FieldsForGUI:
         recipient = None
         amount = None
         description = None
@@ -647,8 +660,7 @@ def get_fields_for_GUI(self, *, bip21_prefer_fallback=False) -> FieldsForGUI:
         elif self.bip21:
             label = self.bip21.get('label')
             address = self.bip21.get('address')
-            sp_address = self.bip21.get(constants.net.BIP352_HRP)
-            if sp_address and not (address and bip21_prefer_fallback): # return fallback address if provided and needed
+            if sp_address := self.bip21.get(constants.net.BIP352_HRP):
                 address = sp_address
             recipient = f'{label} <{address}>' if label else address
             amount = self.bip21.get('amount')
@@ -700,7 +712,7 @@ def has_expired(self):
     def involves_silent_payments(self, wallet_can_send_sp=True) -> bool:
         try:
             return any(o.is_silent_payment() for o
-                       in self.get_onchain_outputs(0, bip21_use_fallback=not wallet_can_send_sp))
+                       in self.get_onchain_outputs(0, allow_silent_payment=wallet_can_send_sp))
         except MissingFallbackAddress:
             # BIP21 URI contained only a silent payment address, and the wallet cannot send to it.
             # Since no fallback address was provided, we treat this as involving silent payments.
@@ -726,7 +738,7 @@ def invoice_from_payment_identifier(
             invoice.set_amount_msat(int(amount_sat * 1000))
         return invoice
     else:
-        outputs = pi.get_onchain_outputs(amount_sat, bip21_use_fallback=not wallet.can_send_silent_payment())
+        outputs = pi.get_onchain_outputs(amount_sat, allow_silent_payment=wallet.can_send_silent_payment())
         message = pi.bip21.get('message') if pi.bip21 else message
         bip70_data = pi.bip70_data if pi.bip70 else None
         return wallet.create_invoice(

tests/test_payment_identifier.py

@@ -313,14 +313,16 @@ def test_silent_payment_spk(self):
             f'{sp_addr}   ',
             f'  {sp_addr}',
             f'{sp_addr.upper()}   ',
+            f'some label<{sp_addr}>'
         ]:
             pi = PaymentIdentifier(None, pi_str)
             self.assertTrue(pi.is_valid())
             self.assertTrue(pi.is_available())
-            self.assertTrue(script_to_address(pi.spk) == DummyAddress.SILENT_PAYMENT)
-            self.assertTrue(pi.spk_is_address) # we treat it as is_address to make sure an amount is set
+            self.assertEqual(pi.sp_address.lower(), sp_addr.lower())
+            self.assertEqual(pi.type, PaymentIdentifierType.SILENT_PAYMENT) # we treat it as is_address to make sure an amount is set
             self.assertTrue(pi.involves_silent_payments())
             self.assertTrue(pi.get_onchain_outputs(0)[0].is_silent_payment())
+            self.assertEqual(pi.get_onchain_outputs(0)[0].address, DummyAddress.SILENT_PAYMENT)
 
     def test_silent_payment_multiline(self):
         # sp_addr with same B_Scan
@@ -386,7 +388,7 @@ def test_silent_payment_bip21(self):
         self.assertTrue(pi.involves_silent_payments(True)) # wallet is sp-capable
         self.assertTrue(pi.involves_silent_payments(False)) # wallet is not sp-capable, but there is no fallback -> involves
         # Raise in get_onchain_outputs if fallback is requested but non is present
-        self.assertRaises(MissingFallbackAddress, pi.get_onchain_outputs, 0, bip21_use_fallback=True)
+        self.assertRaises(MissingFallbackAddress, pi.get_onchain_outputs, 0, allow_silent_payment=False)
 
         # test with fallback in context where wallet is silent payment capable
         bip21 = 'bitcoin:1RustyRX2oai4EYYDpQGWvEL62BBGqN9T?sp=sp1qqvwfct0plnus9vnyd08tvvcwq49g7xfjt3fnwcyu5zc29fj969fg7q4ffc6dnhl9anhec779az46rstpp0t6kzxqmg4tkelfhrejl532ycfaxvsj&message=sp_unit_test&amount=0.001'
@@ -398,6 +400,6 @@ def test_silent_payment_bip21(self):
         self.assertFalse(pi.involves_silent_payments(False))  # wallet is not sp-capable, so fallback is taken -> no sp-involvement
         # make sure fallback is taken from get_onchain_outputs if wallet can not send sp
         self.assertEqual(
-            pi.get_onchain_outputs(0, bip21_use_fallback=True)[0].address,
+            pi.get_onchain_outputs(0, allow_silent_payment=False)[0].address,
             '1RustyRX2oai4EYYDpQGWvEL62BBGqN9T'
         )