improving on split payment handling

lnbits/extensions/splitpayments/models.py

@@ -14,7 +14,7 @@ class Target(BaseModel):
 class TargetPutList(BaseModel):
     wallet: str = Query(...)
     alias: str = Query("")
-    percent: float = Query(..., ge=0.01)
+    percent: float = Query(..., ge=0.01, lt=100)
 
 
 class TargetPut(BaseModel):

lnbits/extensions/splitpayments/tasks.py

@@ -1,13 +1,11 @@
 import asyncio
-import json
 
 from loguru import logger
 
-from lnbits.core import db as core_db
-from lnbits.core.crud import create_payment
 from lnbits.core.models import Payment
-from lnbits.helpers import get_current_extension_name, urlsafe_short_hash
-from lnbits.tasks import internal_invoice_queue, register_invoice_listener
+from lnbits.core.services import create_invoice, pay_invoice
+from lnbits.helpers import get_current_extension_name
+from lnbits.tasks import register_invoice_listener
 
 from .crud import get_targets
 
@@ -22,60 +20,36 @@ async def wait_for_paid_invoices():
 
 
 async def on_invoice_paid(payment: Payment) -> None:
-    if payment.extra.get("tag") == "splitpayments" or payment.extra.get("splitted"):
-        # already splitted, ignore
+    if payment.extra.get("tag") == "splitpayments":
+        # already a splitted payment, ignore
         return
 
-    # now we make some special internal transfers (from no one to the receiver)
     targets = await get_targets(payment.wallet_id)
 
     if not targets:
         return
 
-    transfers = [
-        (target.wallet, int(target.percent * payment.amount / 100))
-        for target in targets
-    ]
-    transfers = [(wallet, amount) for wallet, amount in transfers if amount > 0]
-    amount_left = payment.amount - sum([amount for _, amount in transfers])
+    total_percent = sum([target.percent for target in targets])
 
-    if amount_left < 0:
-        logger.error(
-            "splitpayments failure: amount_left is negative.", payment.payment_hash
-        )
+    if total_percent > 100:
+        logger.error("splitpayment failure: total percent adds up to more than 100%")
         return
 
-    # mark the original payment with one extra key, "splitted"
-    # (this prevents us from doing this process again and it's informative)
-    # and reduce it by the amount we're going to send to the producer
-    await core_db.execute(
-        """
-        UPDATE apipayments
-        SET extra = ?, amount = ?
-        WHERE hash = ?
-          AND checking_id NOT LIKE 'internal_%'
-        """,
-        (
-            json.dumps(dict(**payment.extra, splitted=True)),
-            amount_left,
-            payment.payment_hash,
-        ),
-    )
-
-    # perform the internal transfer using the same payment_hash
-    for wallet, amount in transfers:
-        internal_checking_id = f"internal_{urlsafe_short_hash()}"
-        await create_payment(
-            wallet_id=wallet,
-            checking_id=internal_checking_id,
-            payment_request="",
-            payment_hash=payment.payment_hash,
-            amount=amount,
-            memo=payment.memo,
-            pending=False,
+    logger.debug(f"performing split payments to {len(targets)} targets")
+    for target in targets:
+        amount = int(payment.amount * target.percent / 100)  # msats
+        payment_hash, payment_request = await create_invoice(
+            wallet_id=target.wallet,
+            amount=int(amount / 1000),  # sats
+            internal=True,
+            memo=f"split payment: {target.percent}% for {target.alias or target.wallet}",
             extra={"tag": "splitpayments"},
         )
+        logger.debug(f"created split invoice: {payment_hash}")
 
-        # manually send this for now
-        await internal_invoice_queue.put(internal_checking_id)
-    return
+        checking_id = await pay_invoice(
+            payment_request=payment_request,
+            wallet_id=payment.wallet_id,
+            extra={"tag": "splitpayments"},
+        )
+        logger.debug(f"paid split invoice: {checking_id}")