Exemplo n.º 1
0
async def api_lnurl_callback(link_id):
    link = increment_pay_link(link_id, served_pr=1)
    if not link:
        return jsonify({
            "status": "ERROR",
            "reason": "LNURL-pay not found."
        }), HTTPStatus.OK

    payment_hash, payment_request = create_invoice(
        wallet_id=link.wallet,
        amount=link.amount,
        memo=link.description,
        description_hash=hashlib.sha256(
            link.lnurlpay_metadata.encode("utf-8")).digest(),
        extra={"tag": "lnurlp"},
    )

    save_link_invoice(link_id, payment_request)

    resp = LnurlPayActionResponse(
        pr=payment_request,
        success_action=link.success_action(payment_hash),
        routes=[],
    )

    return jsonify(resp.dict()), HTTPStatus.OK
Exemplo n.º 2
0
async def lnurl_callback(paymentid):
    lnurlpospayment = await get_lnurlpospayment(paymentid)
    pos = await get_lnurlpos(lnurlpospayment.posid)
    if not pos:
        return jsonify({"status": "ERROR", "reason": "lnurlpos not found."})
    payment_hash, payment_request = await create_invoice(
        wallet_id=pos.wallet,
        amount=int(lnurlpospayment.sats / 1000),
        memo=pos.title,
        description_hash=hashlib.sha256(
            (LnurlPayMetadata(json.dumps([["text/plain",
                                           str(pos.title)]
                                          ]))).encode("utf-8")).digest(),
        extra={"tag": "lnurlpos"},
    )
    lnurlpospayment = await update_lnurlpospayment(
        lnurlpospayment_id=paymentid, payhash=payment_hash)
    success_action = pos.success_action(paymentid)
    resp = LnurlPayActionResponse(
        pr=payment_request,
        success_action=success_action,
        disposable=False,
        routes=[],
    )
    return jsonify(resp.dict())
Exemplo n.º 3
0
async def lnurl_callback(track_id):
    track = await get_track(track_id)
    if not track:
        return jsonify({"status": "ERROR", "reason": "Couldn't find track."})

    amount_received = int(request.args.get("amount"))

    if amount_received < track.min_sendable:
        return (jsonify(
            LnurlErrorResponse(
                reason=
                f"Amount {round(amount_received / 1000)} is smaller than minimum {math.floor(track.min_sendable)}."
            ).dict()), )
    elif track.max_sendable < amount_received:
        return (jsonify(
            LnurlErrorResponse(
                reason=
                f"Amount {round(amount_received / 1000)} is greater than maximum {math.floor(track.max_sendable)}."
            ).dict()), )

    comment = request.args.get("comment")
    if len(comment or "") > 300:
        return jsonify(
            LnurlErrorResponse(
                reason=
                f"Got a comment with {len(comment)} characters, but can only accept 300"
            ).dict())

    ls = await get_livestream_by_track(track_id)

    payment_hash, payment_request = await create_invoice(
        wallet_id=ls.wallet,
        amount=int(amount_received / 1000),
        memo=await track.fullname(),
        description_hash=hashlib.sha256(
            (await track.lnurlpay_metadata()).encode("utf-8")).digest(),
        extra={
            "tag": "livestream",
            "track": track.id,
            "comment": comment
        },
    )

    if amount_received < track.price_msat:
        success_action = None
    else:
        success_action = track.success_action(payment_hash)

    resp = LnurlPayActionResponse(
        pr=payment_request,
        success_action=success_action,
        routes=[],
    )

    return jsonify(resp.dict())
Exemplo n.º 4
0
async def api_lnurl_callback(link_id):
    link = increment_pay_link(link_id, served_pr=1)
    if not link:
        return jsonify({"status": "ERROR", "reason": "LNURL-pay not found."}), HTTPStatus.OK

    min, max = link.min, link.max
    rate = await get_fiat_rate(link.currency) if link.currency else 1
    if link.currency:
        # allow some fluctuation (as the fiat price may have changed between the calls)
        min = rate * 995 * link.min
        max = rate * 1010 * link.max
    else:
        min = link.min * 1000
        max = link.max * 1000

    amount_received = int(request.args.get("amount"))
    if amount_received < min:
        return (
            jsonify(LnurlErrorResponse(reason=f"Amount {amount_received} is smaller than minimum {min}.").dict()),
            HTTPStatus.OK,
        )
    elif amount_received > max:
        return (
            jsonify(LnurlErrorResponse(reason=f"Amount {amount_received} is greater than maximum {max}.").dict()),
            HTTPStatus.OK,
        )

    comment = request.args.get("comment")
    if len(comment or "") > link.comment_chars:
        return (
            jsonify(
                LnurlErrorResponse(
                    reason=f"Got a comment with {len(comment)} characters, but can only accept {link.comment_chars}"
                ).dict()
            ),
            HTTPStatus.OK,
        )

    payment_hash, payment_request = create_invoice(
        wallet_id=link.wallet,
        amount=int(amount_received / 1000),
        memo=link.description,
        description_hash=hashlib.sha256(link.lnurlpay_metadata.encode("utf-8")).digest(),
        extra={"tag": "lnurlp", "link": link.id, "comment": comment},
    )

    resp = LnurlPayActionResponse(
        pr=payment_request,
        success_action=link.success_action(payment_hash),
        routes=[],
    )

    return jsonify(resp.dict()), HTTPStatus.OK
Exemplo n.º 5
0
async def lnurl_callback(cp_id):
    cp = await get_copilot(cp_id)
    if not cp:
        return jsonify({"status": "ERROR", "reason": "Copilot not found."})

    amount_received = int(request.args.get("amount"))

    if amount_received < 10000:
        return (jsonify(
            LnurlErrorResponse(
                reason=
                f"Amount {round(amount_received / 1000)} is smaller than minimum 10 sats."
            ).dict()), )
    elif amount_received / 1000 > 10000000:
        return (jsonify(
            LnurlErrorResponse(
                reason=
                f"Amount {round(amount_received / 1000)} is greater than maximum 50000."
            ).dict()), )
    comment = ""
    if request.args.get("comment"):
        comment = request.args.get("comment")
        if len(comment or "") > 300:
            return jsonify(
                LnurlErrorResponse(
                    reason=
                    f"Got a comment with {len(comment)} characters, but can only accept 300"
                ).dict())
        if len(comment) < 1:
            comment = "none"

    payment_hash, payment_request = await create_invoice(
        wallet_id=cp.wallet,
        amount=int(amount_received / 1000),
        memo=cp.lnurl_title,
        description_hash=hashlib.sha256(
            (LnurlPayMetadata(json.dumps([["text/plain",
                                           str(cp.lnurl_title)]
                                          ]))).encode("utf-8")).digest(),
        extra={
            "tag": "copilot",
            "copilot": cp.id,
            "comment": comment
        },
    )
    resp = LnurlPayActionResponse(
        pr=payment_request,
        success_action=None,
        disposable=False,
        routes=[],
    )
    return jsonify(resp.dict())
Exemplo n.º 6
0
async def lnurl_callback(item_id):
    item = await get_item(item_id)
    if not item:
        return jsonify({"status": "ERROR", "reason": "Couldn't find item."})

    if item.unit == "sat":
        min = item.price * 1000
        max = item.price * 1000
    else:
        price = await fiat_amount_as_satoshis(item.price, item.unit)
        # allow some fluctuation (the fiat price may have changed between the calls)
        min = price * 995
        max = price * 1010

    amount_received = int(request.args.get("amount") or 0)
    if amount_received < min:
        return jsonify(
            LnurlErrorResponse(
                reason=f"Amount {amount_received} is smaller than minimum {min}."
            ).dict())
    elif amount_received > max:
        return jsonify(
            LnurlErrorResponse(
                reason=f"Amount {amount_received} is greater than maximum {max}."
            ).dict())

    shop = await get_shop(item.shop)

    try:
        payment_hash, payment_request = await create_invoice(
            wallet_id=shop.wallet,
            amount=int(amount_received / 1000),
            memo=item.name,
            description_hash=hashlib.sha256(
                (await item.lnurlpay_metadata()).encode("utf-8")).digest(),
            extra={
                "tag": "offlineshop",
                "item": item.id
            },
        )
    except Exception as exc:
        return jsonify(LnurlErrorResponse(reason=exc.message).dict())

    resp = LnurlPayActionResponse(
        pr=payment_request,
        success_action=item.success_action(shop, payment_hash)
        if shop.method else None,
        routes=[],
    )

    return jsonify(resp.dict())
Exemplo n.º 7
0
async def api_lnurlp_callback(link_id):
    link = await get_satsdice_pay(link_id)
    if not link:
        return (
            jsonify({
                "status": "ERROR",
                "reason": "LNUeL-pay not found."
            }),
            HTTPStatus.OK,
        )

    min, max = link.min_bet, link.max_bet
    min = link.min_bet * 1000
    max = link.max_bet * 1000

    amount_received = int(request.args.get("amount") or 0)
    if amount_received < min:
        return (
            jsonify(
                LnurlErrorResponse(
                    reason=
                    f"Amount {amount_received} is smaller than minimum {min}."
                ).dict()),
            HTTPStatus.OK,
        )
    elif amount_received > max:
        return (
            jsonify(
                LnurlErrorResponse(
                    reason=
                    f"Amount {amount_received} is greater than maximum {max}."
                ).dict()),
            HTTPStatus.OK,
        )

    payment_hash, payment_request = await create_invoice(
        wallet_id=link.wallet,
        amount=int(amount_received / 1000),
        memo="Satsdice bet",
        description_hash=hashlib.sha256(
            link.lnurlpay_metadata.encode("utf-8")).digest(),
        extra={
            "tag": "satsdice",
            "link": link.id,
            "comment": "comment"
        },
    )

    success_action = link.success_action(payment_hash)
    link = await create_satsdice_payment(satsdice_pay=link.id,
                                         value=amount_received / 1000,
                                         payment_hash=payment_hash)
    if success_action:
        resp = LnurlPayActionResponse(
            pr=payment_request,
            success_action=success_action,
            routes=[],
        )
    else:
        resp = LnurlPayActionResponse(
            pr=payment_request,
            routes=[],
        )

    return jsonify(resp.dict()), HTTPStatus.OK