fix: reconcile LuckyPot entry requests

Author: jackharrhy

.gitignore

@@ -9,7 +9,10 @@ wheels/
 
 .env
 *.db
+*.db-shm
+*.db-wal
 *.log
+data/
 
 tmp
 PLAN.md

luckypot/db.py

@@ -148,7 +148,7 @@ def get_entry_by_id(conn, entry_id: int) -> dict | None:
 def get_entry_by_request_id(conn, request_id: str) -> dict | None:
     """Get a pot entry by its StackCoin request ID, including pot guild_id."""
     cursor = conn.execute(
-        """SELECT pe.*, p.guild_id AS pot_guild_id
+        """SELECT pe.*, p.guild_id AS pot_guild_id, p.is_active AS pot_is_active
            FROM pot_entries pe
            JOIN pots p ON pe.pot_id = p.pot_id
            WHERE pe.stackcoin_request_id = ?""",

luckypot/discord/commands.py

@@ -28,6 +28,7 @@ async def invoke(self, ctx: lightbulb.Context) -> None:
             discord_id = str(ctx.user.id)
 
             try:
+                await ctx.defer(ephemeral=True)
                 guild_announce = partial(announce, guild_id)
                 result = await enter_pot(
                     discord_id, guild_id, announce_fn=guild_announce

luckypot/game.py

@@ -129,7 +129,11 @@ async def enter_pot(
                 }
 
             stk_user_id = stk_user["id"]
-            idempotency_key = f"pot_entry:{pot_id}:{discord_id}"
+            prior_attempts = conn.execute(
+                "SELECT COUNT(*) AS count FROM pot_entries WHERE pot_id = ? AND discord_id = ?",
+                (pot_id, discord_id),
+            ).fetchone()["count"]
+            idempotency_key = f"pot_entry:{pot_id}:{discord_id}:{prior_attempts + 1}"
             req = await stk.create_request(
                 to_user_id=stk_user_id,
                 amount=POT_ENTRY_COST,
@@ -144,13 +148,23 @@ async def enter_pot(
 
             request_id = str(req["request_id"])
 
-            entry_id = db.add_entry(
-                conn,
-                pot_id=pot_id,
-                discord_id=discord_id,
-                amount=POT_ENTRY_COST,
-                stackcoin_request_id=request_id,
-            )
+            try:
+                entry_id = db.add_entry(
+                    conn,
+                    pot_id=pot_id,
+                    discord_id=discord_id,
+                    amount=POT_ENTRY_COST,
+                    stackcoin_request_id=request_id,
+                )
+            except Exception:
+                await stk.deny_request(int(request_id))
+                logger.exception(
+                    f"Failed to persist entry for request_id={request_id}; denied remote request"
+                )
+                return {
+                    "status": "error",
+                    "message": "Failed to record your pot entry. The StackCoin request was cancelled; please try again.",
+                }
 
             return {
                 "status": "pending",
@@ -171,11 +185,11 @@ def select_random_winner(participants: list[dict]) -> dict | None:
     if not participants:
         return None
 
-    total_weight = sum(p["amount"] for p in participants)
+    total_weight = sum(max(p["amount"], POT_ENTRY_COST) for p in participants)
     roll = random.uniform(0, total_weight)
     cumulative = 0
     for p in participants:
-        cumulative += p["amount"]
+        cumulative += max(p["amount"], POT_ENTRY_COST)
         if roll <= cumulative:
             return p
     return participants[-1]
@@ -461,7 +475,26 @@ async def on_request_accepted(
             discord_id = entry["discord_id"]
             announce_fn = partial(announce, guild_id) if announce else None
 
-            if entry["status"] == "pending":
+            if entry["status"] == "pending" and not entry["pot_is_active"]:
+                refunded = await send_winnings_to_user(
+                    discord_id,
+                    entry["amount"],
+                    idempotency_key=f"pot_refund:{request_id}",
+                )
+                if refunded:
+                    db.deny_entry(conn, entry_id)
+                    logger.info(
+                        f"Entry {entry_id} refunded for discord_id={discord_id}; pot already ended"
+                    )
+                    if announce_fn:
+                        await announce_fn(
+                            f"<@{discord_id}>'s late pot payment was refunded because that pot already ended."
+                        )
+                else:
+                    logger.error(
+                        f"Failed to refund late accepted entry {entry_id} for discord_id={discord_id}"
+                    )
+            elif entry["status"] == "pending":
                 db.confirm_entry(conn, entry_id)
                 logger.info(f"Entry {entry_id} confirmed for discord_id={discord_id}")
                 if announce_fn:

luckypot/stk.py

@@ -141,6 +141,16 @@ async def create_request(
         return None
 
 
+async def deny_request(request_id: int) -> bool:
+    """Deny a payment request. Returns True if the request was denied."""
+    try:
+        result = await get_client().deny_request(request_id=request_id)
+        return result.success is True
+    except stackcoin.StackCoinError as e:
+        logger.error(f"Failed to deny request {request_id}: {e}")
+        return False
+
+
 async def get_request(request_id: int) -> dict | None:
     """Get a request by ID."""
     try: