fastapi

mint/app.py

@@ -1,67 +1,148 @@
-import hashlib
-
 from ecc.curve import secp256k1, Point
-from flask import Flask, request
-import os
+from fastapi import FastAPI
+from fastapi.routing import APIRouter
+from fastapi.params import Depends, Query, Body
+
+import sys
 import asyncio
+import logging
+import uvicorn
+from loguru import logger
 
 from mint.ledger import Ledger
 from mint.migrations import m001_initial
 from lightning import WALLET
+import core.settings as settings
+
+from core.base import MintPayload, MintPayloads, SplitPayload
+
+# from .app import create_app
+
 
 # Ledger pubkey
-ledger = Ledger("supersecretprivatekey", "../data/mint")
+ledger = Ledger("supersecretprivatekey", "data/mint")
 
 
-class MyFlaskApp(Flask):
-    """
-    We overload the Flask class so we can run a startup script (migration).
-    Stupid Flask.
-    """
+# class MyFlaskApp(Flask):
+#     """
+#     We overload the Flask class so we can run a startup script (migration).
+#     Stupid Flask.
+#     """
 
-    def __init__(self, *args, **kwargs):
-        async def create_tasks_func():
-            await asyncio.wait([m001_initial(ledger.db)])
-            await ledger.load_used_proofs()
+#     def __init__(self, *args, **kwargs):
+#         async def create_tasks_func():
+#             await asyncio.wait([m001_initial(ledger.db)])
+#             await ledger.load_used_proofs()
 
-            error_message, balance = await WALLET.status()
-            if error_message:
-                print(
-                    f"The backend for {WALLET.__class__.__name__} isn't working properly: '{error_message}'",
-                    RuntimeWarning,
-                )
+#             error_message, balance = await WALLET.status()
+#             if error_message:
+#                 print(
+#                     f"The backend for {WALLET.__class__.__name__} isn't working properly: '{error_message}'",
+#                     RuntimeWarning,
+#                 )
 
-            print(f"Lightning balance: {balance} sat")
+#             print(f"Lightning balance: {balance} sat")
 
-            print("Mint started.")
+#             print("Mint started.")
 
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(create_tasks_func())
-        loop.close()
+#         loop = asyncio.get_event_loop()
+#         loop.run_until_complete(create_tasks_func())
+#         loop.close()
 
-        return super().__init__(*args, **kwargs)
+#         return super().__init__(*args, **kwargs)
 
-    def run(self, *args, **options):
-        super(MyFlaskApp, self).run(*args, **options)
+#     def run(self, *args, **options):
+#         super(MyFlaskApp, self).run(*args, **options)
 
 
-app = MyFlaskApp(__name__)
+def startup(app: FastAPI):
+    @app.on_event("startup")
+    async def load_ledger():
+        await asyncio.wait([m001_initial(ledger.db)])
+        await ledger.load_used_proofs()
+
+        error_message, balance = await WALLET.status()
+        if error_message:
+            logger.warning(
+                f"The backend for {WALLET.__class__.__name__} isn't working properly: '{error_message}'",
+                RuntimeWarning,
+            )
+
+        logger.info(f"Lightning balance: {balance} sat")
+
+        logger.info("Mint started.")
 
 
-@app.route("/keys")
+def create_app(config_object="core.settings") -> FastAPI:
+    def configure_logger() -> None:
+        class Formatter:
+            def __init__(self):
+                self.padding = 0
+                self.minimal_fmt: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SS}</green> | <level>{level}</level> | <level>{message}</level>\n"
+                if settings.DEBUG:
+                    self.fmt: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SS}</green> | <level>{level: <4}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | <level>{message}</level>\n"
+                else:
+                    self.fmt: str = self.minimal_fmt
+
+            def format(self, record):
+                function = "{function}".format(**record)
+                if function == "emit":  # uvicorn logs
+                    return self.minimal_fmt
+                return self.fmt
+
+        class InterceptHandler(logging.Handler):
+            def emit(self, record):
+                try:
+                    level = logger.level(record.levelname).name
+                except ValueError:
+                    level = record.levelno
+                logger.log(level, record.getMessage())
+
+        logger.remove()
+        log_level: str = "INFO"
+        formatter = Formatter()
+        logger.add(sys.stderr, level=log_level, format=formatter.format)
+
+        logging.getLogger("uvicorn").handlers = [InterceptHandler()]
+        logging.getLogger("uvicorn.access").handlers = [InterceptHandler()]
+
+    configure_logger()
+
+    app = FastAPI(
+        title="Cashu Mint",
+        description="Ecash wallet and mint.",
+        license_info={
+            "name": "MIT License",
+            "url": "https://raw.githubusercontent.com/callebtc/cashu/main/LICENSE",
+        },
+    )
+
+    startup(app)
+    return app
+
+
+app = create_app()
+
+
+@app.get("/")
+async def root():
+    return {"Hello": "world"}
+
+
+@app.get("/keys")
 def keys():
     return ledger.get_pubkeys()
 
 
-@app.route("/mint", methods=["POST"])
-async def mint():
-    payload = request.json
+@app.post("/mint")
+async def mint(payloads: MintPayloads):
     amounts = []
     B_s = []
-    for k, v in payload.items():
+    for payload in payloads.payloads:
+        v = payload.dict()
         amounts.append(v["amount"])
-        x = int(v["x"])
-        y = int(v["y"])
+        x = int(v["B_"]["x"])
+        y = int(v["B_"]["y"])
         B_ = Point(x, y, secp256k1)
         B_s.append(B_)
     try:
@@ -71,13 +152,18 @@ async def mint():
         return {"error": str(exc)}
 
 
-@app.route("/split", methods=["POST"])
-async def split():
-    proofs = request.json["proofs"]
-    amount = request.json["amount"]
-    output_data = request.json["output_data"]
+@app.post("/split")
+async def split(payload: SplitPayload):
+    v = payload.dict()
+    proofs = v["proofs"]
+    amount = v["amount"]
+    output_data = v["output_data"]["payloads"]
     try:
         fst_promises, snd_promises = await ledger.split(proofs, amount, output_data)
         return {"fst": fst_promises, "snd": snd_promises}
     except Exception as exc:
         return {"error": str(exc)}
+
+
+# if __name__ == "__main__":
+#     uvicorn.run(app, host="127.0.0.1", port=5049)