millisat precision

electrum/gui/qml/components/InvoiceDialog.qml

@@ -237,8 +237,8 @@ ElDialog {
                                 }
                                 Connections {
                                     target: invoice.amountOverride
-                                    function onSatsIntChanged() {
-                                        console.log('amountOverride satsIntChanged, sats=' + invoice.amountOverride.satsInt)
+                                    function onValueChanged() {
+                                        console.log('amountOverride valueChanged, sats=' + invoice.amountOverride.satsInt)
                                         if (amountMax.checked)  // amountOverride updated by max amount estimate
                                             amountBtc.text = Config.formatSatsForEditing(invoice.amountOverride.satsInt)
                                     }

electrum/gui/qml/components/OpenChannelDialog.qml

@@ -177,7 +177,7 @@ ElDialog {
 
                     Connections {
                         target: channelopener.amount
-                        function onSatsIntChanged() {
+                        function onValueChanged() {
                             if (is_max.checked)  // amount updated by max amount estimate
                                 amountBtc.text = Config.formatSatsForEditing(channelopener.amount.satsInt)
                         }

electrum/gui/qml/components/controls/BtcField.qml

@@ -27,7 +27,7 @@ TextField {
     Connections {
         target: Config
         function onBaseUnitChanged() {
-            amount.text = amount.textAsSats.satsInt != 0
+            amount.text = amount.textAsSats.msatsInt != 0
                 ? Config.satsToUnits(amount.textAsSats)
                 : ''
         }

electrum/gui/qml/components/controls/ChannelBar.qml

@@ -22,7 +22,7 @@ Item {
     }
 
     function do_update() {
-        var cap = capacity.satsInt * 1000
+        var cap = capacity.msatsInt
         var twocap = cap * 2
         l1.width = width * (cap - localCapacity.msatsInt) / twocap
         if (frozenForSending) {
@@ -48,22 +48,22 @@ Item {
 
     Connections {
         target: localCapacity
-        function onMsatsIntChanged() { update() }
+        function onValueChanged() { update() }
     }
 
     Connections {
         target: remoteCapacity
-        function onMsatsIntChanged() { update() }
+        function onValueChanged() { update() }
     }
 
     Connections {
         target: canSend
-        function onMsatsIntChanged() { update() }
+        function onValueChanged() { update() }
     }
 
     Connections {
         target: canReceive
-        function onMsatsIntChanged() { update() }
+        function onValueChanged() { update() }
     }
 
     Rectangle {

electrum/gui/qml/components/controls/FormattedAmount.qml

@@ -26,7 +26,7 @@ GridLayout {
     }
     Label {
         visible: valid
-        text: amount.msatsInt != 0 ? Config.formatMilliSats(amount) : Config.formatSats(amount)
+        text: Config.formatMilliSats(amount)
         font.family: FixedFont
     }
     Label {

electrum/gui/qml/components/controls/HistoryItemDelegate.qml

@@ -106,10 +106,10 @@ Item {
                     font.pixelSize: constants.fontSizeMedium
                     Layout.alignment: Qt.AlignRight
                     font.bold: true
-                    color: model.value.satsInt >= 0 ? constants.colorCredit : constants.colorDebit
+                    color: model.value.msatsInt >= 0 ? constants.colorCredit : constants.colorDebit
 
                     function updateText() {
-                        text = Config.formatSats(model.value)
+                        text = Config.formatMilliSats(model.value)
                     }
                     Component.onCompleted: updateText()
                 }

electrum/gui/qml/components/controls/InvoiceDelegate.qml

@@ -77,7 +77,7 @@ ItemDelegate {
                     ? ''
                     : model.amount.isMax
                         ? 'MAX'
-                        : Config.formatSats(model.amount)
+                        : Config.formatMilliSats(model.amount)
                 font.pixelSize: constants.fontSizeMedium
                 font.family: FixedFont
             }
@@ -142,10 +142,10 @@ ItemDelegate {
     Connections {
         target: Config
         function onBaseUnitChanged() {
-            amount.text = model.amount.isEmpty ? '' : Config.formatSats(model.amount)
+            amount.text = model.amount.isEmpty ? '' : Config.formatMilliSats(model.amount)
         }
         function onThousandsSeparatorChanged() {
-            amount.text = model.amount.isEmpty ? '' : Config.formatSats(model.amount)
+            amount.text = model.amount.isEmpty ? '' : Config.formatMilliSats(model.amount)
         }
     }
     Connections {

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
 
@@ -360,6 +360,21 @@ def formatSatsForEditing(self, satoshis):
             add_thousands_sep=False,
         )
 
+    @pyqtSlot('qint64', result=str)
+    @pyqtSlot(QEAmount, result=str)
+    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(
+            satoshis,
+            add_thousands_sep=False,
+            precision=precision,
+        )
+
     @pyqtSlot('qint64', result=str)
     @pyqtSlot('qint64', bool, result=str)
     @pyqtSlot(QEAmount, result=str)
@@ -372,16 +387,23 @@ def formatSats(self, satoshis, with_unit=False):
         else:
             return self.config.format_amount(satoshis)
 
+    @pyqtSlot('qint64', result=str)
+    @pyqtSlot('qint64', bool, result=str)
     @pyqtSlot(QEAmount, result=str)
     @pyqtSlot(QEAmount, bool, result=str)
     def formatMilliSats(self, amount, with_unit=False):
-        assert isinstance(amount, QEAmount), f"unexpected type for amount: {type(amount)}"
-        msats = amount.msatsInt
+        if isinstance(amount, QEAmount):
+            msats = amount.msatsInt
+        elif isinstance(amount, int):
+            msats = amount
+        else:
+            raise Exception(f"Unknown amount type: {str(type(amount))}")
+        sats = Decimal(msats) / 1000
         precision = 3  # config.amt_precision_post_satoshi is not exposed in preferences
         if with_unit:
-            return self.config.format_amount_and_units(msats/1000, precision=precision)
+            return self.config.format_amount_and_units(sats, precision=precision)
         else:
-            return self.config.format_amount(msats/1000, precision=precision)
+            return self.config.format_amount(sats, precision=precision)
 
     @pyqtSlot(str, result=QEAmount)
     def unitsToSats(self, unitAmount):
@@ -391,11 +413,9 @@ def unitsToSats(self, unitAmount):
         except Exception:
             return self._amount
 
-        sat_max_precision = self.config.BTC_AMOUNTS_DECIMAL_POINT
         msat_max_precision = self.config.BTC_AMOUNTS_DECIMAL_POINT + 3
-        sat_max_prec_amount = int(pow(10, sat_max_precision) * x)
         msat_max_prec_amount = int(pow(10, msat_max_precision) * x)
-        self._amount = QEAmount(amount_sat=sat_max_prec_amount, amount_msat=msat_max_prec_amount)
+        self._amount = QEAmount(amount_msat=msat_max_prec_amount)
         return self._amount
 
     @pyqtSlot('quint64', result=float)

electrum/gui/qml/qetransactionlistmodel.py

@@ -134,11 +134,11 @@ def tx_to_model(self, tx_item):
             item['lightning'] = False
 
         if item['lightning']:
-            item['value'] = QEAmount(amount_sat=item['value'].value, amount_msat=item['amount_msat'])
+            item['value'] = QEAmount(amount_msat=item['amount_msat'])
             item['incoming'] = True if item['amount_msat'] > 0 else False
             item['confirmations'] = 0
         else:
-            item['value'] = QEAmount(amount_sat=item['value'].value)
+            item['value'] = QEAmount(amount_sat=int(item['value'].value))
 
         if 'txid' in item:
             tx = self.wallet.db.get_transaction(item['txid'])

electrum/gui/qml/qetypes.py

@@ -1,3 +1,5 @@
+from decimal import Decimal
+
 from PyQt6.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject
 
 from electrum.logging import get_logger
@@ -7,7 +9,6 @@
 class QEAmount(QObject):
     """Container for bitcoin amounts that can be passed around more
        easily between python, QML-property and QML-javascript contexts.
-       Note: millisat and sat amounts are not synchronized!
 
        QML type 'int' in property definitions is 32 bit signed, so will overflow easily
        on (milli)satoshi amounts! 'int' in QML-javascript seems to be larger than 32 bit, and
@@ -20,32 +21,50 @@ class QEAmount(QObject):
 
     _logger = get_logger(__name__)
 
-    def __init__(self, *, amount_sat: int = 0, amount_msat: int = 0, is_max: bool = False, from_invoice=None, parent=None):
+    valueChanged = pyqtSignal()
+
+    def __init__(self, *, amount_sat: int = None, amount_msat: int = None, is_max: bool = False, from_invoice=None, parent=None):
         super().__init__(parent)
-        self._amount_sat = int(amount_sat) if amount_sat is not None else None
-        self._amount_msat = int(amount_msat) if amount_msat is not None else None
+
+        self._amount_msat = None
+        if amount_sat is not None:
+            assert isinstance(amount_sat, int)
+            self._amount_msat = self._sat_to_msat(amount_sat)
+        if amount_msat is not None:
+            assert isinstance(amount_msat, int)
+            if amount_sat is not None:
+                assert amount_sat == self._msat_to_sat(amount_msat)  # if both defined, assert conversion is as expected
+            self._amount_msat = amount_msat
+        if is_max:
+            assert amount_sat is None and amount_msat is None
+
         self._is_max = is_max
         if from_invoice:
+            assert amount_sat is None and amount_msat is None, 'cannot combine from_invoice and amount_(m)sat'
             inv_amt = from_invoice.get_amount_msat()
             if inv_amt == '!':
                 self._is_max = True
             elif inv_amt is not None:
                 self._amount_msat = int(inv_amt)
-                self._amount_sat = int(from_invoice.get_amount_sat())
 
-    valueChanged = pyqtSignal()
+    def _sat_to_msat(self, amount_sat: int | None) -> int | None:
+        return amount_sat * 1000 if amount_sat is not None else None
+
+    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):
-        if self._amount_sat is None:  # should normally be defined when accessing this property
-            self._logger.warning('amount_sat is undefined, returning 0')
+        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_sat
+        return self._msat_to_sat(self._amount_msat)
 
     @satsInt.setter
     def satsInt(self, sats):
-        if self._amount_sat != sats:
-            self._amount_sat = sats
+        msats = self._sat_to_msat(sats)
+        if self._amount_msat != msats:
+            self._amount_msat = msats
             self.valueChanged.emit()
 
     @pyqtProperty('qint64', notify=valueChanged)
@@ -63,7 +82,7 @@ def msatsInt(self, msats):
 
     @pyqtProperty(str, notify=valueChanged)
     def satsStr(self):
-        return str(self._amount_sat)
+        return str(self._msat_to_sat(self._amount_msat))
 
     @pyqtProperty(str, notify=valueChanged)
     def msatsStr(self):
@@ -81,11 +100,14 @@ def isMax(self, ismax):
 
     @pyqtProperty(bool, notify=valueChanged)
     def isEmpty(self):
-        return not(self._is_max or self._amount_sat or self._amount_msat)
+        return not (self._is_max or self._amount_msat)
+
+    @pyqtProperty(bool, notify=valueChanged)
+    def hasMsatPrecision(self):
+        return not (self._amount_msat == self._sat_to_msat(self._msat_to_sat(self._amount_msat)))
 
     @pyqtSlot()
     def clear(self):
-        self._amount_sat = 0
         self._amount_msat = 0
         self._is_max = False
         self.valueChanged.emit()
@@ -95,28 +117,33 @@ def copyFrom(self, amount):
         if not amount:
             self._logger.warning('copyFrom with None argument. assuming 0')  # TODO
             amount = QEAmount()
-        self.satsInt = amount.satsInt
-        self.msatsInt = amount.msatsInt
-        self.isMax = amount.isMax
+
+        changed = False
+        if self._amount_msat != amount._amount_msat:
+            self._amount_msat = amount._amount_msat
+            changed = True
+        if self._is_max != amount._is_max:
+            self._is_max = amount._is_max
+            changed = True
+        if changed:
+            self.valueChanged.emit()
 
     def __eq__(self, other):
         if isinstance(other, QEAmount):
-            return self._amount_sat == other._amount_sat and self._amount_msat == other._amount_msat and self._is_max == other._is_max
+            return self._amount_msat == other._amount_msat and self._is_max == other._is_max
         elif isinstance(other, int):
-            return self._amount_sat == other
-        elif isinstance(other, str):
-            return self.satsStr == other
+            return self._amount_msat == other
 
         return False
 
     def __str__(self):
         s = _('Amount')
         if self._is_max:
             return '%s(MAX)' % s
-        return '%s(sats=%d, msats=%d)' % (s, self._amount_sat, self._amount_msat)
+        return '%s(sats=%s, msats=%s)' % (s, str(self._msat_to_sat(self._amount_msat)), str(self._amount_msat))
 
     def __repr__(self):
-        return f"<QEAmount max={self._is_max} sats={self._amount_sat} msats={self._amount_msat} empty={self.isEmpty}>"
+        return f"<QEAmount max={self._is_max} sats={self._msat_to_sat(self._amount_msat)} msats={self._amount_msat} empty={self.isEmpty}>"
 
 
 class QEBytes(QObject):