fixes

Author: accumulator

electrum/gui/qml/qeconfig.py

@@ -1,6 +1,6 @@
 import copy
 from decimal import Decimal
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from PyQt6.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject, QRegularExpression
 
@@ -362,11 +362,11 @@ def formatSatsForEditing(self, satoshis):
 
     @pyqtSlot('qint64', result=str)
     @pyqtSlot(QEAmount, result=str)
-    def formatMilliSatsForEditing(self, satoshis):
-        if isinstance(satoshis, QEAmount):
-            satoshis = Decimal(satoshis.msatsInt) / 1000
-        elif isinstance(satoshis, int):
-            satoshis = Decimal(satoshis) / 1000
+    def formatMilliSatsForEditing(self, msatoshis):
+        if isinstance(msatoshis, QEAmount):
+            satoshis = Decimal(msatoshis.msatsInt) / 1000
+        elif isinstance(msatoshis, int):
+            satoshis = Decimal(msatoshis) / 1000
 
         precision = 3  # config.amt_precision_post_satoshi is not exposed in preferences
         return self.config.format_amount(
@@ -380,8 +380,6 @@ def formatMilliSatsForEditing(self, satoshis):
     @pyqtSlot(QEAmount, result=str)
     @pyqtSlot(QEAmount, bool, result=str)
     def formatSats(self, satoshis, with_unit=False):
-        if satoshis is None:
-            return ''
         if isinstance(satoshis, QEAmount):
             satoshis = satoshis.satsInt
         if with_unit:
@@ -394,8 +392,6 @@ def formatSats(self, satoshis, with_unit=False):
     @pyqtSlot(QEAmount, result=str)
     @pyqtSlot(QEAmount, bool, result=str)
     def formatMilliSats(self, amount, with_unit=False):
-        if amount is None:
-            return ''
         if isinstance(amount, QEAmount):
             msats = amount.msatsInt
         elif isinstance(amount, int):

electrum/gui/qml/qefx.py

@@ -161,7 +161,7 @@ def satoshiValue(self, fiat):
             return ''
         v = fd / Decimal(rate) * COIN
         if not v.is_nan():
-            self._amount.satsInt = v.to_integral_value()
+            self._amount.satsInt = int(v.to_integral_value())
         return self._amount
 
     @pyqtSlot(str, result=bool)

electrum/gui/qml/qetypes.py

@@ -54,28 +54,30 @@ def _msat_to_sat(self, amount_msat: int | None) -> int | None:
         return int(Decimal(amount_msat) / 1000) if amount_msat is not None else None
 
     @pyqtProperty('qint64', notify=valueChanged)
-    def satsInt(self):
+    def satsInt(self) -> int:
         if self._amount_msat is None:  # should normally be defined when accessing this property
             self._logger.warning('amount_msat is undefined, returning 0')
             return 0
         return self._msat_to_sat(self._amount_msat)
 
     @satsInt.setter
-    def satsInt(self, sats):
+    def satsInt(self, sats: int):
+        assert sats is None or isinstance(sats, int), 'sats must be int or None'
         msats = self._sat_to_msat(sats)
         if self._amount_msat != msats:
             self._amount_msat = msats
             self.valueChanged.emit()
 
     @pyqtProperty('qint64', notify=valueChanged)
-    def msatsInt(self):
+    def msatsInt(self) -> int:
         if self._amount_msat is None:  # should normally be defined when accessing this property
             self._logger.warning('amount_msat is undefined, returning 0')
             return 0
         return self._amount_msat
 
     @msatsInt.setter
-    def msatsInt(self, msats):
+    def msatsInt(self, msats: int):
+        assert msats is None or isinstance(msats, int), 'msats must be int or None'
         if self._amount_msat != msats:
             self._amount_msat = msats
             self.valueChanged.emit()
@@ -137,8 +139,7 @@ def lt(self, other: 'QEAmount|None') -> bool:
         if other is None:
             other = QEAmount()
         assert isinstance(other, QEAmount)
-        if self.isMax or other.isMax:
-            return False
+        assert not (self.isMax or other.isMax), "'lt/lte' operator undefined for MAX amounts"
         if self.isEmpty and not other.isEmpty:
             return True
         return self.msatsInt < other.msatsInt
@@ -152,8 +153,7 @@ def gt(self, other: 'QEAmount|None') -> bool:
         if other is None:
             other = QEAmount()
         assert isinstance(other, QEAmount)
-        if self.isMax or other.isMax:
-            return False
+        assert not (self.isMax or other.isMax), "'gt/gte' operator undefined for MAX amounts"
         if self.isEmpty and not other.isEmpty:
             return False
         return self.msatsInt > other.msatsInt
@@ -174,6 +174,13 @@ def max(self, one: 'QEAmount|None', two: 'QEAmount|None'):
             two = QEAmount()
         assert isinstance(one, QEAmount)
         assert isinstance(two, QEAmount)
+        # TODO: as gt/lt is undefined for operands being isMax, we can either
+        #  - raise (let the GUI avoid comparisons against MAX)
+        #  - define MAX as always being larger than any value
+        if one.isMax:
+            return one
+        if two.isMax:
+            return two
         return one if one.gt(two) else two
 
     @pyqtSlot('QVariant', 'QVariant', result='QVariant')
@@ -184,23 +191,30 @@ def min(self, one: 'QEAmount|None', two: 'QEAmount|None'):
             two = QEAmount()
         assert isinstance(one, QEAmount)
         assert isinstance(two, QEAmount)
+        # TODO: as gt/lt is undefined for operands being isMax, we can either
+        #  - raise (let the GUI avoid comparisons against MAX)
+        #  - define MAX as always being larger than any value
+        if one.isMax:
+            return two
+        if two.isMax:
+            return one
         return one if one.lt(two) else two
 
-    def __eq__(self, other):
-        if isinstance(other, QEAmount):
-            return self._amount_msat == other._amount_msat and self._is_max == other._is_max
-        elif isinstance(other, int):
-            return self._amount_msat == other
+    def __eq__(self, other: 'QEAmount') -> bool:
+        assert True if other is None else isinstance(other, QEAmount)
 
-        return False
+        if other is None:
+            return False
 
-    def __str__(self):
+        return self._amount_msat == other._amount_msat and self._is_max == other._is_max
+
+    def __str__(self) -> str:
         s = _('Amount')
         if self._is_max:
             return '%s(MAX)' % s
         return '%s(sats=%s, msats=%s)' % (s, str(self._msat_to_sat(self._amount_msat)), str(self._amount_msat))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<QEAmount max={self._is_max} sats={self._msat_to_sat(self._amount_msat)} msats={self._amount_msat} empty={self.isEmpty}>"
 
 

electrum/gui/qml/qewallet.py

@@ -703,9 +703,13 @@ def createRequest(self, amount: QEAmount, message: str, expiration: int, lightni
                 addr = None
 
             if lightning:
-                key = self.wallet.create_request(amount_msat=amount.msatsInt, message=message, exp_delay=expiration)
+                amount_msat = None if amount.msatsInt == 0 else amount.msatsInt
+                key = self.wallet.create_request(amount_msat=amount_msat, message=message, exp_delay=expiration)
             else:
-                key = self.wallet.create_request(amount_sat=amount.satsInt, message=message, exp_delay=expiration, address=addr)
+                amount_sat = None if amount.satsInt == 0 else amount.satsInt
+                # GUI should not allow msat precision, but assert here to be sure
+                assert amount.satsInt * 1000 == amount.msatsInt, 'onchain createRequest should not have msat precision'
+                key = self.wallet.create_request(amount_sat=amount_sat, message=message, exp_delay=expiration, address=addr)
         except InvoiceError as e:
             self.requestCreateError.emit(_('Error creating payment request') + ':\n' + str(e))
             return

electrum/gui/qt/amountedit.py

@@ -121,7 +121,7 @@ def _get_text_from_amount(self, amount) -> str:
         return text
 
     def setAmount(self, amount):
-        text = self._get_text_from_amount(amount)
+        text = self._get_text_from_amount(amount) if amount is not None else " "
         self.setText(text)
 
 

electrum/payment_identifier.py

@@ -389,7 +389,7 @@ async def _do_finalize(
             if not self.lnurl_data:
                 raise Exception("Unexpected missing LNURL data")
 
-            amount_msat = amount_sat * 1000
+            amount_msat = int(amount_sat * 1000)
             if not (self.lnurl_data.min_sendable_msat <= amount_msat <= self.lnurl_data.max_sendable_msat):
                 self.error = _('Amount must be between {} and {} sat.').format(
                     Decimal(self.lnurl_data.min_sendable_msat) / 1000,

electrum/wallet.py

@@ -3038,13 +3038,15 @@ def create_request(
         elif amount_sat is not None:
             assert isinstance(amount_sat, int), f"{amount_msat!r}"
             amount_msat = amount_sat * 1000
-        else:
-            amount_msat = None
 
         message = message or ''
         address = address or None  # converts "" to None
         exp_delay = exp_delay or 0
         timestamp = int(Request._get_cur_time())
+        payment_hash = None
+        outputs = []
+
+        # lightning/onchain
         if address is None:
             assert self.has_lightning()
             payment_hash = self.lnworker.create_payment_info(
@@ -3053,8 +3055,9 @@ def create_request(
                 write_to_disk=False,
             )
         else:
-            payment_hash = None
-        outputs = [PartialTxOutput.from_address_and_value(address, amount_sat)] if address else []
+            amount_sat = 0 if amount_sat is None else amount_sat
+            outputs = [PartialTxOutput.from_address_and_value(address, amount_sat)]
+
         height = self.adb.get_local_height()
         req = Request(
             outputs=outputs,

tests/qml/test_qml_types.py

@@ -186,10 +186,14 @@ def test_lt_gt_eq(self):
 
         d = QEAmount(is_max=True)
 
-        self.assertFalse(d.lt(a))
-        self.assertFalse(d.gt(a))
-        self.assertFalse(a.lt(d))
-        self.assertFalse(a.gt(d))
+        with self.assertRaises(AssertionError):
+            d.lt(a)
+        with self.assertRaises(AssertionError):
+            d.gt(a)
+        with self.assertRaises(AssertionError):
+            a.lt(d)
+        with self.assertRaises(AssertionError):
+            a.gt(d)
 
         e = QEAmount(amount_msat=200)
         self.assertTrue(e.lte(b))