Resync points balances

apps/scoutgamecron/src/scripts/detectAndResolveBalanceIssues.ts

@@ -0,0 +1,77 @@
+import { log } from "@charmverse/core/log";
+import { prisma } from "@charmverse/core/prisma-client";
+import { currentSeason, getCurrentWeek } from "@packages/scoutgame/dates";
+import { getPointStatsFromHistory } from "@packages/scoutgame/points/getPointStatsFromHistory";
+
+
+
+async function detectBalanceIssues() {
+  const scouts = await prisma.scout.findMany({
+    orderBy: {
+      farcasterId: 'asc'
+    },
+    select: {
+      id: true,
+      farcasterId: true,
+      farcasterName: true,
+      currentBalance: true
+    }
+  });
+  const totalScouts = scouts.length;
+
+  log.info(`Checking ${totalScouts} scouts for balance issues...`);
+
+  const scoutsWithBalanceIssues = [];
+
+  for (let i = 0; i < totalScouts; i++) {
+    log.info(`Checking scout ${i + 1} of ${totalScouts}: fid=${scouts[i].farcasterId}, name=${scouts[i].farcasterName}`);
+    const scout = scouts[i];
+
+    const balances = await getPointStatsFromHistory({
+      userIdOrUsername: scout.id
+    });
+
+    if (balances.balance !== scout.currentBalance) {
+
+      log.error(`Scout (id: ${scout.id})  (fid:${scout.farcasterId}) has a balance discrepancy: ${balances.balance} (computed) vs ${scout.currentBalance} (current)`)
+      scoutsWithBalanceIssues.push({
+        farcasterId: scout.farcasterId,
+        scoutId: scout.id,
+        expectedBalance: balances.balance,
+        currentBalance: scout.currentBalance,
+        pointDetails: balances
+      });
+    }
+  }
+
+  return scoutsWithBalanceIssues;
+}
+
+async function resolveBalanceIssues() {
+  const balanceIssues = await detectBalanceIssues();
+
+  for (let i = 0; i < balanceIssues.length; i++) {
+    const balanceToResolve = balanceIssues[i];
+
+    await prisma.builderEvent.create({
+      data: {
+        season: currentSeason,
+        type: 'misc_event',
+        week: getCurrentWeek(),
+        builder: {
+          connect: {
+            id: balanceToResolve.scoutId
+          }
+        },
+        pointsReceipts: {
+          create: {
+            value: balanceToResolve.expectedBalance - balanceToResolve.currentBalance,
+            recipientId: balanceToResolve.scoutId
+          }
+        }
+      }
+    })
+  }
+}
+
+// detectBalanceIssues().then(console.log)

apps/scoutgamecron/src/scripts/manualNftResync.ts

@@ -0,0 +1,17 @@
+import { syncUserNFTsFromOnchainData } from "@packages/scoutgame/builderNfts/syncUserNFTsFromOnchainData";
+
+
+
+const username = ''
+
+export async function manualNftResync() {
+  if (!username) {
+    throw new Error('Please provide a username');
+  };
+
+  await syncUserNFTsFromOnchainData({username})
+  console.log('manualNftResync');
+}
+
+
+// manualNftResync().then(console.log)

apps/scoutgamecron/src/tasks/resolveMissingPurchases/index.ts

@@ -5,6 +5,7 @@ import { resolveMissingPurchases } from './resolveMissingPurchases';
 
 export async function resolveMissingPurchasesTask(ctx: Koa.Context) {
   log.info('Resyncing builder NFT sales');
-  await resolveMissingPurchases({ minutesAgoToNow: 5 });
+  // This task is run every 5 minutes. Adding some padding so we don't miss any transactions
+  await resolveMissingPurchases({ minutesAgoToNow: 7 });
   log.info(`Syncing complete`);
 }

package.json

@@ -58,9 +58,9 @@
     "start:remote": "concurrently --names \"next,sockets\" -c \"green,yellow\" \"npm run server:remote\" \"npm run sockets:remote\"",
     "start:staging": "concurrently --names \"next,sockets\" -c \"green,yellow\" \"REACT_APP_WEBSOCKETS_HOST=http://127.0.0.1:3336 npm run server:staging\" \"npm run sockets:staging\"",
     "prepare": "husky install",
-    "db-tool": "npx prisma studio",
-    "db-tool:dev": "dotenv -e .env.local -- npx prisma studio",
-    "db-tool:test": "dotenv -e .env.test.local -- npx prisma studio",
+    "db-tool": "npx prisma studio --schema=node_modules/@charmverse/core/src/prisma/schema.prisma",
+    "db-tool:dev": "dotenv -e .env.local -- npx prisma studio --schema=node_modules/@charmverse/core/src/prisma/schema.prisma",
+    "db-tool:test": "dotenv -e .env.test.local -- npx prisma studio --schema=node_modules/@charmverse/core/src/prisma/schema.prisma",
     "serverless:build": "dotenv -e .env.local -- npx serverless package",
     "serverless:start": "dotenv -e .env.test.local -- serverless offline start --httpPort=3020",
     "typecheck": "NODE_OPTIONS=\"--max_old_space_size=4096\" node_modules/typescript/bin/tsc --project tsconfig.json --noEmit",

packages/scoutgame/src/builderNfts/syncUserNFTsFromOnchainData.ts

@@ -35,37 +35,51 @@ export async function syncUserNFTsFromOnchainData({
   const txRequiringReconciliation = userPurchases.filter((p) => !p.nftPurchase);
 
   for (let i = 0; i < txRequiringReconciliation.length; i++) {
-    log.info(`Processing missing tx ${i + 1} / ${txRequiringReconciliation.length}`);
+    const txToReconcile = txRequiringReconciliation[i];
 
-    const tx = txRequiringReconciliation[i];
+    log.error(`Processing missing txToReconcile ${i + 1} / ${txRequiringReconciliation.length}`, {
+      sourceTransaction: txToReconcile.pendingTransaction?.sourceChainTxHash,
+      sourceChain: txToReconcile.pendingTransaction?.sourceChainId,
+      optimismTxHash: txToReconcile.txHash,
+      tokenId: txToReconcile.tokenId,
+      scoutId: txToReconcile.scoutId,
+      tokensToPurchase: txToReconcile.amount
+    });
     const expectedPrice =
-      tx.pendingTransaction?.targetAmountReceived ??
+      txToReconcile.pendingTransaction?.targetAmountReceived ??
       (await getTokenPurchasePrice({
         args: {
-          amount: BigInt(tx.amount),
-          tokenId: BigInt(tx.tokenId)
+          amount: BigInt(txToReconcile.amount),
+          tokenId: BigInt(txToReconcile.tokenId)
         },
-        blockNumber: BigInt(tx.blockNumber) - BigInt(1)
+        blockNumber: BigInt(txToReconcile.blockNumber) - BigInt(1)
       }));
 
+    if (!txToReconcile.pendingTransaction) {
+      log.error('No pending transaction found for txToReconcile', {
+        scoutId: txToReconcile.scoutId,
+        tokenId: txToReconcile.tokenId,
+        tokensToPurchase: txToReconcile.amount
+      });
+    }
     const pendingTx =
-      tx.pendingTransaction ??
+      txToReconcile.pendingTransaction ??
       (await savePendingTransaction({
         user: {
           scoutId: scout.id,
-          walletAddress: tx.transferEvent.to
+          walletAddress: txToReconcile.transferEvent.to
         },
         transactionInfo: {
           destinationChainId: 10,
           sourceChainId: 10,
-          sourceChainTxHash: tx.txHash
+          sourceChainTxHash: txToReconcile.txHash
         },
         purchaseInfo: {
           quotedPriceCurrency: optimismUsdcContractAddress,
           builderContractAddress: realOptimismMainnetBuildersContract,
-          tokenId: parseInt(tx.tokenId),
+          tokenId: parseInt(txToReconcile.tokenId),
           quotedPrice: Number(expectedPrice.toString()),
-          tokenAmount: Number(tx.amount)
+          tokenAmount: Number(txToReconcile.amount)
         }
       }));