Merge branch 'main' into switchpasstag

2022-12-14 00:18:46 +00:00 · 2022-12-14 00:18:46 +00:00 · 7b2b1de681
commit 7b2b1de681
parent 75e6252d23 cc60e11226
14 changed files with 195 additions and 62 deletions
--- a/lnbits/core/crud.py
+++ b/lnbits/core/crud.py
@ -339,37 +339,14 @@ async def delete_expired_invoices(
          AND time < {db.timestamp_now} - {db.interval_seconds(2592000)}
        """
    )
-
-    # then we delete all expired invoices, checking one by one
-    rows = await (conn or db).fetchall(
+    # then we delete all invoices whose expiry date is in the past
+    await (conn or db).execute(
        f"""
-        SELECT bolt11
-        FROM apipayments
-        WHERE pending = true
-          AND bolt11 IS NOT NULL
-          AND amount > 0 AND time < {db.timestamp_now} - {db.interval_seconds(86400)}
+        DELETE FROM apipayments
+        WHERE pending = true AND amount > 0
+          AND expiry < {db.timestamp_now}
        """
    )
-    logger.debug(f"Checking expiry of {len(rows)} invoices")
-    for i, (payment_request,) in enumerate(rows):
-        try:
-            invoice = bolt11.decode(payment_request)
-        except:
-            continue
-
-        expiration_date = datetime.datetime.fromtimestamp(invoice.date + invoice.expiry)
-        if expiration_date > datetime.datetime.utcnow():
-            continue
-        logger.debug(
-            f"Deleting expired invoice {i}/{len(rows)}: {invoice.payment_hash} (expired: {expiration_date})"
-        )
-        await (conn or db).execute(
-            """
-            DELETE FROM apipayments
-            WHERE pending = true AND hash = ?
-            """,
-            (invoice.payment_hash,),
-        )


 # payments
@ -396,12 +373,19 @@ async def create_payment(
    # previous_payment = await get_wallet_payment(wallet_id, payment_hash, conn=conn)
    # assert previous_payment is None, "Payment already exists"

+    try:
+        invoice = bolt11.decode(payment_request)
+        expiration_date = datetime.datetime.fromtimestamp(invoice.date + invoice.expiry)
+    except:
+        # assume maximum bolt11 expiry of 31 days to be on the safe side
+        expiration_date = datetime.datetime.now() + datetime.timedelta(days=31)
+
    await (conn or db).execute(
        """
        INSERT INTO apipayments
          (wallet, checking_id, bolt11, hash, preimage,
-           amount, pending, memo, fee, extra, webhook)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           amount, pending, memo, fee, extra, webhook, expiry)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """,
        (
            wallet_id,
@ -417,6 +401,7 @@ async def create_payment(
            if extra and extra != {} and type(extra) is dict
            else None,
            webhook,
+            db.datetime_to_timestamp(expiration_date),
        ),
    )

--- a/lnbits/core/migrations.py
+++ b/lnbits/core/migrations.py
@ -1,5 +1,10 @@
+import datetime
+
+from loguru import logger
 from sqlalchemy.exc import OperationalError  # type: ignore

+from lnbits import bolt11
+

 async def m000_create_migrations_table(db):
    await db.execute(
@ -188,3 +193,68 @@ async def m005_balance_check_balance_notify(db):
        );
    """
    )
+
+
+async def m006_add_invoice_expiry_to_apipayments(db):
+    """
+    Adds invoice expiry column to apipayments.
+    """
+    try:
+        await db.execute("ALTER TABLE apipayments ADD COLUMN expiry TIMESTAMP")
+    except OperationalError:
+        pass
+
+
+async def m007_set_invoice_expiries(db):
+    """
+    Precomputes invoice expiry for existing pending incoming payments.
+    """
+    try:
+        rows = await (
+            await db.execute(
+                f"""
+                SELECT bolt11, checking_id
+                FROM apipayments
+                WHERE pending = true
+                AND amount > 0
+                AND bolt11 IS NOT NULL
+                AND expiry IS NULL
+                AND time < {db.timestamp_now}
+                """
+            )
+        ).fetchall()
+        if len(rows):
+            logger.info(f"Mirgraion: Checking expiry of {len(rows)} invoices")
+        for i, (
+            payment_request,
+            checking_id,
+        ) in enumerate(rows):
+            try:
+                invoice = bolt11.decode(payment_request)
+                if invoice.expiry is None:
+                    continue
+
+                expiration_date = datetime.datetime.fromtimestamp(
+                    invoice.date + invoice.expiry
+                )
+                logger.info(
+                    f"Mirgraion: {i+1}/{len(rows)} setting expiry of invoice {invoice.payment_hash} to {expiration_date}"
+                )
+                await db.execute(
+                    """
+                    UPDATE apipayments SET expiry = ?
+                    WHERE checking_id = ? AND amount > 0
+                    """,
+                    (
+                        db.datetime_to_timestamp(expiration_date),
+                        checking_id,
+                    ),
+                )
+            except:
+                continue
+    except OperationalError:
+        # this is necessary now because it may be the case that this migration will
+        # run twice in some environments.
+        # catching errors like this won't be necessary in anymore now that we
+        # keep track of db versions so no migration ever runs twice.
+        pass
--- a/lnbits/core/models.py
+++ b/lnbits/core/models.py
@ -1,6 +1,8 @@
+import datetime
 import hashlib
 import hmac
 import json
+import time
 from sqlite3 import Row
 from typing import Dict, List, NamedTuple, Optional

@ -83,6 +85,7 @@ class Payment(BaseModel):
    bolt11: str
    preimage: str
    payment_hash: str
+    expiry: Optional[float]
    extra: Optional[Dict] = {}
    wallet_id: str
    webhook: Optional[str]
@ -101,6 +104,7 @@ class Payment(BaseModel):
            fee=row["fee"],
            memo=row["memo"],
            time=row["time"],
+            expiry=row["expiry"],
            wallet_id=row["wallet"],
            webhook=row["webhook"],
            webhook_status=row["webhook_status"],
@ -128,6 +132,10 @@ class Payment(BaseModel):
    def is_out(self) -> bool:
        return self.amount < 0

+    @property
+    def is_expired(self) -> bool:
+        return self.expiry < time.time() if self.expiry else False
+
    @property
    def is_uncheckable(self) -> bool:
        return self.checking_id.startswith("internal_")
@ -170,7 +178,13 @@ class Payment(BaseModel):

        logger.debug(f"Status: {status}")

-        if self.is_out and status.failed:
+        if self.is_in and status.pending and self.is_expired and self.expiry:
+            expiration_date = datetime.datetime.fromtimestamp(self.expiry)
+            logger.debug(
+                f"Deleting expired incoming pending payment {self.checking_id}: expired {expiration_date}"
+            )
+            await self.delete(conn)
+        elif self.is_out and status.failed:
            logger.warning(
                f"Deleting outgoing failed payment {self.checking_id}: {status}"
            )
--- a/lnbits/db.py
+++ b/lnbits/db.py
@ -29,6 +29,13 @@ class Compat:
            return f"{seconds}"
        return "<nothing>"

+    def datetime_to_timestamp(self, date: datetime.datetime):
+        if self.type in {POSTGRES, COCKROACH}:
+            return date.strftime("%Y-%m-%d %H:%M:%S")
+        elif self.type == SQLITE:
+            return time.mktime(date.timetuple())
+        return "<nothing>"
+
    @property
    def timestamp_now(self) -> str:
        if self.type in {POSTGRES, COCKROACH}:
@ -125,6 +132,8 @@ class Database(Compat):
            import psycopg2  # type: ignore

            def _parse_timestamp(value, _):
+                if value is None:
+                    return None
                f = "%Y-%m-%d %H:%M:%S.%f"
                if not "." in value:
                    f = "%Y-%m-%d %H:%M:%S"
@ -149,14 +158,7 @@ class Database(Compat):

            psycopg2.extensions.register_type(
                psycopg2.extensions.new_type(
-                    (1184, 1114),
-                    "TIMESTAMP2INT",
-                    _parse_timestamp
-                    # lambda value, curs: time.mktime(
-                    #     datetime.datetime.strptime(
-                    #         value, "%Y-%m-%d %H:%M:%S.%f"
-                    #     ).timetuple()
-                    # ),
+                    (1184, 1114), "TIMESTAMP2INT", _parse_timestamp
                )
            )
        else:
--- a/lnbits/extensions/cashu/templates/cashu/wallet.html
+++ b/lnbits/extensions/cashu/templates/cashu/wallet.html
@ -1,5 +1,5 @@
-{% extends "public.html" %} {% block toolbar_title %} {% raw %} {{name}} Cashu
-{% endraw %} {% endblock %} {% block footer %}{% endblock %} {% block
+{% extends "public.html" %} {% block toolbar_title %} {% raw %} Cashu {% endraw
+%} - {{mint_name}} {% endblock %} {% block footer %}{% endblock %} {% block
 page_container %}
 <q-page-container>
  <q-page>
@ -752,7 +752,13 @@ page_container %}
          </div>

          <div class="row q-mt-lg">
-            <q-btn @click="redeem" color="primary">Receive Tokens</q-btn>
+            <q-btn @click="redeem" color="primary">Receive</q-btn>
+            <q-btn
+              unelevated
+              icon="content_copy"
+              class="q-mx-0"
+              @click="copyText(receiveData.tokensBase64)"
+            ></q-btn>
            <q-btn
              unelevated
              icon="photo_camera"
--- a/lnbits/extensions/cashu/views.py
+++ b/lnbits/extensions/cashu/views.py
@ -27,11 +27,17 @@ async def index(

@cashu_ext.get("/wallet")
 async def wallet(request: Request, mint_id: str):
+    cashu = await get_cashu(mint_id)
+    if not cashu:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
+        )
    return cashu_renderer().TemplateResponse(
        "cashu/wallet.html",
        {
            "request": request,
            "web_manifest": f"/cashu/manifest/{mint_id}.webmanifest",
+            "mint_name": cashu.name,
        },
    )

@ -41,7 +47,7 @@ async def cashu(request: Request, mintID):
    cashu = await get_cashu(mintID)
    if not cashu:
        raise HTTPException(
-            status_code=HTTPStatus.NOT_FOUND, detail="TPoS does not exist."
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
        )
    return cashu_renderer().TemplateResponse(
        "cashu/mint.html",
@ -54,7 +60,7 @@ async def manifest(cashu_id: str):
    cashu = await get_cashu(cashu_id)
    if not cashu:
        raise HTTPException(
-            status_code=HTTPStatus.NOT_FOUND, detail="TPoS does not exist."
+            status_code=HTTPStatus.NOT_FOUND, detail="Mint does not exist."
        )

    return {
--- a/lnbits/extensions/cashu/views_api.py
+++ b/lnbits/extensions/cashu/views_api.py
@ -280,22 +280,33 @@ async def melt_coins(
        fees_msat = fee_reserve(invoice_obj.amount_msat)
    else:
        fees_msat = 0
-    assert total_provided >= amount + fees_msat / 1000, Exception(
+    assert total_provided >= amount + math.ceil(fees_msat / 1000), Exception(
        f"Provided proofs ({total_provided} sats) not enough for Lightning payment ({amount + fees_msat} sats)."
    )
-
+    logger.debug(f"Cashu: Initiating payment of {total_provided} sats")
    await pay_invoice(
        wallet_id=cashu.wallet,
        payment_request=invoice,
-        description=f"pay cashu invoice",
-        extra={"tag": "cashu", "cahsu_name": cashu.name},
+        description=f"Pay cashu invoice",
+        extra={"tag": "cashu", "cashu_name": cashu.name},
    )

-    status: PaymentStatus = await check_transaction_status(
-        cashu.wallet, invoice_obj.payment_hash
-    )
-    if status.paid == True:
+    try:
+        logger.debug(
+            f"Cashu: Wallet {cashu.wallet} checking PaymentStatus of {invoice_obj.payment_hash}"
+        )
+        status: PaymentStatus = await check_transaction_status(
+            cashu.wallet, invoice_obj.payment_hash
+        )
+        logger.debug(f"Cashu: Got status.paid: {status.paid}")
+        if status.paid == True:
+            logger.debug("Cashu: Payment successful, invalidating proofs")
+            await ledger._invalidate_proofs(proofs)
+    except Exception as e:
+        logger.error(e)
+        logger.error("Cashu: Error in payment status check, invalidating proofs")
        await ledger._invalidate_proofs(proofs)
+
    return GetMeltResponse(paid=status.paid, preimage=status.preimage)


@ -333,7 +344,7 @@ async def check_fees(
        fees_msat = fee_reserve(invoice_obj.amount_msat)
    else:
        fees_msat = 0
-    return CheckFeesResponse(fee=fees_msat / 1000)
+    return CheckFeesResponse(fee=math.ceil(fees_msat / 1000))


@cashu_ext.post("/api/v1/{cashu_id}/split")
--- a/lnbits/extensions/satspay/helpers.py
+++ b/lnbits/extensions/satspay/helpers.py
@ -37,7 +37,11 @@ async def call_webhook(charge: Charges):
                json=public_charge(charge),
                timeout=40,
            )
-            return {"webhook_success": r.is_success, "webhook_message": r.reason_phrase}
+            return {
+                "webhook_success": r.is_success,
+                "webhook_message": r.reason_phrase,
+                "webhook_response": r.text,
+            }
        except Exception as e:
            logger.warning(f"Failed to call webhook for charge {charge.id}")
            logger.warning(e)
--- a/lnbits/extensions/satspay/static/js/utils.js
+++ b/lnbits/extensions/satspay/static/js/utils.js
@ -23,6 +23,7 @@ const mapCharge = (obj, oldObj = {}) => {
  charge.displayUrl = ['/satspay/', obj.id].join('')
  charge.expanded = oldObj.expanded || false
  charge.pendingBalance = oldObj.pendingBalance || 0
+  charge.extra = charge.extra ? JSON.parse(charge.extra) : charge.extra
  return charge
 }

--- a/lnbits/extensions/satspay/templates/satspay/index.html
+++ b/lnbits/extensions/satspay/templates/satspay/index.html
@ -227,7 +227,12 @@
                    >
                  </div>
                  <div class="col-4 q-pr-lg">
-                    <q-badge v-if="props.row.webhook_message" color="blue">
+                    <q-badge
+                      v-if="props.row.webhook_message"
+                      @click="showWebhookResponseDialog(props.row.extra.webhook_response)"
+                      color="blue"
+                      class="cursor-pointer"
+                    >
                      {{props.row.webhook_message }}
                    </q-badge>
                  </div>
@ -528,6 +533,23 @@
      </q-form>
    </q-card>
  </q-dialog>
+
+  <q-dialog v-model="showWebhookResponse" position="top">
+    <q-card class="q-pa-lg q-pt-xl lnbits__dialog-card">
+      <q-input
+        filled
+        dense
+        readonly
+        v-model.trim="webhookResponse"
+        type="textarea"
+        label="Response"
+      ></q-input>
+
+      <div class="row q-mt-lg">
+        <q-btn flat v-close-popup color="grey" class="q-ml-auto">Close</q-btn>
+      </div>
+    </q-card>
+  </q-dialog>
 </div>
 {% endblock %} {% block scripts %} {{ window_vars(user) }}
 <!-- lnbits/static/vendor
@ -669,7 +691,9 @@
          data: {
            custom_css: ''
          }
-        }
+        },
+        showWebhookResponse: false,
+        webhookResponse: ''
      }
    },
    methods: {
@ -757,7 +781,6 @@
            '/satspay/api/v1/themes',
            this.g.user.wallets[0].inkey
          )
-          console.log(data)
          this.themeLinks = data.map(c =>
            mapCSS(
              c,
@ -852,14 +875,12 @@
      },
      updateformDialog: function (themeId) {
        const theme = _.findWhere(this.themeLinks, {css_id: themeId})
-        console.log(theme.css_id)
        this.formDialogThemes.data.css_id = theme.css_id
        this.formDialogThemes.data.title = theme.title
        this.formDialogThemes.data.custom_css = theme.custom_css
        this.formDialogThemes.show = true
      },
      createTheme: async function (wallet, data) {
-        console.log(data.css_id)
        try {
          if (data.css_id) {
            const resp = await LNbits.api.request(
@ -887,7 +908,6 @@
            custom_css: ''
          }
        } catch (error) {
-          console.log('cun')
          LNbits.utils.notifyApiError(error)
        }
      },
@ -955,6 +975,10 @@
            }
          })
      },
+      showWebhookResponseDialog(webhookResponse) {
+        this.webhookResponse = webhookResponse
+        this.showWebhookResponse = true
+      },
      exportchargeCSV: function () {
        LNbits.utils.exportCSV(
          this.chargesTable.columns,
--- a/lnbits/static/js/base.js
+++ b/lnbits/static/js/base.js
@ -184,6 +184,7 @@ window.LNbits = {
        bolt11: data.bolt11,
        preimage: data.preimage,
        payment_hash: data.payment_hash,
+        expiry: data.expiry,
        extra: data.extra,
        wallet_id: data.wallet_id,
        webhook: data.webhook,
@ -195,6 +196,11 @@ window.LNbits = {
        'YYYY-MM-DD HH:mm'
      )
      obj.dateFrom = moment(obj.date).fromNow()
+      obj.expirydate = Quasar.utils.date.formatDate(
+        new Date(obj.expiry * 1000),
+        'YYYY-MM-DD HH:mm'
+      )
+      obj.expirydateFrom = moment(obj.expirydate).fromNow()
      obj.msat = obj.amount
      obj.sat = obj.msat / 1000
      obj.tag = obj.extra.tag
--- a/lnbits/static/js/components.js
+++ b/lnbits/static/js/components.js
@ -192,9 +192,13 @@ Vue.component('lnbits-payment-details', {
        </q-badge>
      </div>
      <div class="row">
-        <div class="col-3"><b>Date</b>:</div>
+        <div class="col-3"><b>Created</b>:</div>
        <div class="col-9">{{ payment.date }} ({{ payment.dateFrom }})</div>
      </div>
+      <div class="row">
+        <div class="col-3"><b>Expiry</b>:</div>
+        <div class="col-9">{{ payment.expirydate }} ({{ payment.expirydateFrom }})</div>
+      </div>      
      <div class="row">
        <div class="col-3"><b>Description</b>:</div>
        <div class="col-9">{{ payment.memo }}</div>
--- a/lnbits/tasks.py
+++ b/lnbits/tasks.py
@ -145,7 +145,7 @@ async def check_pending_payments():
            )
            # we delete expired invoices once upon the first pending check
            if incoming:
-                logger.info("Task: deleting all expired invoices")
+                logger.debug("Task: deleting all expired invoices")
                start_time: float = time.time()
                await delete_expired_invoices(conn=conn)
                logger.info(
--- a/tests/data/mock_data.zip
+++ b/tests/data/mock_data.zip