fix melt and mint list

Author: shroominic

sixty_nuts/lnurl.py

@@ -24,6 +24,82 @@ class LNURLError(Exception):
     """LNURL related errors."""
 
 
+def parse_lightning_invoice_amount(invoice: str, currency: str = "sat") -> int:
+    """Parse Lightning invoice (BOLT-11) to extract amount in specified currency units.
+
+    Args:
+        invoice: BOLT-11 Lightning invoice string
+        currency: Target currency unit ("sat" or "msat")
+
+    Returns:
+        Amount in the specified currency unit
+
+    Raises:
+        LNURLError: If invoice format is invalid or amount cannot be parsed
+    """
+    invoice = invoice.lower().strip()
+
+    if not invoice.startswith("ln"):
+        raise LNURLError("Invalid Lightning invoice format")
+
+    # Find the network part (bc, tb, etc.)
+    network_start = 2
+    while network_start < len(invoice) and invoice[network_start] not in "0123456789":
+        network_start += 1
+
+    if network_start >= len(invoice):
+        raise LNURLError("Invalid Lightning invoice format")
+
+    # Parse amount and multiplier
+    amount_str = ""
+    multiplier = ""
+    i = network_start
+
+    # Extract numeric part
+    while i < len(invoice) and invoice[i].isdigit():
+        amount_str += invoice[i]
+        i += 1
+
+    # Extract multiplier if present
+    if i < len(invoice) and invoice[i] in "munp":
+        multiplier = invoice[i]
+        i += 1
+
+    # Check if we have the required "1" separator
+    if i >= len(invoice) or invoice[i] != "1":
+        raise LNURLError("Invalid Lightning invoice format")
+
+    if not amount_str:
+        raise LNURLError("Lightning invoice amount not specified")
+
+    # Convert to base units
+    try:
+        amount = int(amount_str)
+    except ValueError:
+        raise LNURLError("Invalid Lightning invoice amount")
+
+    # Apply multiplier to get millisatoshis
+    if multiplier == "m":  # milli = 10^-3
+        amount_msat = amount * 100_000_000  # amount is in BTC * 10^-3
+    elif multiplier == "u":  # micro = 10^-6
+        amount_msat = amount * 100_000  # amount is in BTC * 10^-6
+    elif multiplier == "n":  # nano = 10^-9
+        amount_msat = amount * 100  # amount is in BTC * 10^-9
+    elif multiplier == "p":  # pico = 10^-12
+        amount_msat = amount // 10  # amount is in BTC * 10^-12
+    else:
+        # No multiplier means the amount is in BTC
+        amount_msat = amount * 100_000_000_000  # Convert BTC to msat
+
+    # Convert to target currency unit
+    if currency == "msat":
+        return amount_msat
+    elif currency == "sat":
+        return amount_msat // 1000
+    else:
+        raise LNURLError(f"Unsupported currency for Lightning: {currency}")
+
+
 async def decode_lnurl(lnurl: str) -> str:
     """Decode LNURL to get the actual URL.
 

sixty_nuts/wallet.py

@@ -34,6 +34,12 @@
     get_pubkey,
     nip44_decrypt,
 )
+from .lnurl import (
+    get_lnurl_data,
+    get_lnurl_invoice,
+    parse_lightning_invoice_amount,
+    LNURLError,
+)
 from .types import ProofDict, WalletError
 from .events import EventManager
 
@@ -583,6 +589,7 @@ async def melt(self, invoice: str, *, target_mint: str | None = None) -> None:
 
         Args:
             invoice: BOLT-11 Lightning invoice to pay
+            target_mint: Target mint URL (defaults to primary mint)
 
         Raises:
             WalletError: If insufficient balance or payment fails
@@ -593,28 +600,61 @@ async def melt(self, invoice: str, *, target_mint: str | None = None) -> None:
         if target_mint is None:
             target_mint = self.mint_urls[0]
 
-        invoice_amount = 0  # TODO: get_invoice_amount_with_fees(invoice)
+        try:
+            invoice_amount = parse_lightning_invoice_amount(invoice, self.currency)
+        except LNURLError as e:
+            raise WalletError(f"Invalid Lightning invoice: {e}") from e
 
+        # Get current state and check balance
         state = await self.fetch_wallet_state(check_proofs=True)
-        self.raise_if_insufficient_balance(state.balance, invoice_amount)
 
+        # Create melt quote to get fees
+        mint = self._get_mint(target_mint)
+        melt_quote = await mint.create_melt_quote(unit=self.currency, request=invoice)
+        fee_reserve = melt_quote.get("fee_reserve", 0)
+        total_needed = invoice_amount + fee_reserve
+
+        self.raise_if_insufficient_balance(state.balance, total_needed)
+
+        # Select proofs for the total amount needed (invoice + fees)
         selected_proofs, consumed_proofs = await self._select_proofs(
-            state.proofs, invoice_amount, target_mint
+            state.proofs, total_needed, target_mint
         )
-        print(selected_proofs)
-        # TODO: self.mark_pending_proofs(selected_proofs)
 
-        # melt proofs and pay invoice
-        mint = self._get_mint(target_mint)
-        melt_quote = await mint.create_melt_quote(unit=self.currency, request=invoice)
-        print(melt_quote)
-        # TODO: convert selected_proofs to mint format
-        # melt_resp = await mint.melt(quote=melt_quote["quote"], inputs=selected_proofs)
+        # Convert selected proofs to mint format
+        mint_proofs = [self._proofdict_to_mint_proof(p) for p in selected_proofs]
 
-        # TODO: check success and undo if failed or retry
+        # Execute the melt operation
+        melt_resp = await mint.melt(quote=melt_quote["quote"], inputs=mint_proofs)
 
-        # TODO: publish spending history with fee information
-        pass
+        # Check if payment was successful
+        if not melt_resp.get("paid", False):
+            raise WalletError(
+                f"Lightning payment failed. State: {melt_resp.get('state', 'unknown')}"
+            )
+
+        # Handle any change returned from the mint
+        change_proofs: list[ProofDict] = []
+        if "change" in melt_resp and melt_resp["change"]:
+            # Convert BlindedSignatures to ProofDict format
+            # This would require unblinding logic, but for now we'll skip change handling
+            # In practice, most melts shouldn't have change if amounts are selected properly
+            pass
+
+        # Mark the consumed input proofs as spent
+        await self._mark_proofs_as_spent(consumed_proofs)
+
+        # Store any change proofs
+        if change_proofs:
+            await self.store_proofs(change_proofs)
+
+        # Publish spending history
+        event_manager = await self._ensure_event_manager()
+        await event_manager.publish_spending_history(
+            direction="out",
+            amount=invoice_amount,  # The actual invoice amount paid
+            destroyed_token_ids=[],  # Will be handled by _mark_proofs_as_spent
+        )
 
     async def send(
         self,
@@ -700,7 +740,6 @@ async def send_to_lnurl(self, lnurl: str, amount: int) -> int:
             paid = await wallet.send_to_lnurl("user@getalby.com", 1000)
             print(f"Paid {paid} sats")
         """
-        from .lnurl import get_lnurl_data, get_lnurl_invoice
 
         # Get current balance
         state = await self.fetch_wallet_state(check_proofs=True)
@@ -1777,13 +1816,17 @@ async def fetch_wallet_state(self, *, check_proofs: bool = True) -> WalletState:
                 decrypted = nip44_decrypt(wallet_event["content"], self._privkey)
                 wallet_data = json.loads(decrypted)
 
-                # Update mint URLs from wallet event
-                self.mint_urls = []
+                # Update mint URLs from wallet event (only if event contains mint URLs)
+                event_mint_urls = []
                 for item in wallet_data:
                     if item[0] == "mint":
-                        self.mint_urls.append(item[1])
+                        event_mint_urls.append(item[1])
                     elif item[0] == "privkey":
                         self.wallet_privkey = item[1]
+
+                # Only update mint URLs if the event actually contains some
+                if event_mint_urls:
+                    self.mint_urls = event_mint_urls
             except Exception as e:
                 # Skip wallet event if it can't be decrypted
                 print(f"Warning: Could not decrypt wallet event: {e}")