Add payout modes and production switchover schema

src/ORM/_views/user-agent-report/user-agent-report.service.spec.ts

@@ -0,0 +1,149 @@
+import { UserAgentReportService } from './user-agent-report.service';
+
+describe('UserAgentReportService', () => {
+    const originalApiOnly = process.env.API_ONLY;
+
+    afterEach(() => {
+        if (originalApiOnly == null) {
+            delete process.env.API_ONLY;
+        } else {
+            process.env.API_ONLY = originalApiOnly;
+        }
+    });
+
+    it('uses Redis live presence in API-only processes when workers are connected', async () => {
+        process.env.API_ONLY = 'true';
+        const userAgentReport = {
+            find: jest.fn().mockResolvedValue([
+                {
+                    userAgent: 'db-view',
+                    count: '1',
+                    bestDifficulty: 0,
+                    totalHashRate: '0',
+                },
+            ]),
+        };
+        const clientRepository = {
+            find: jest.fn().mockResolvedValue([{ id: 'client-1' }]),
+        };
+        const redisMessagingService = {
+            getJsonCache: jest.fn().mockResolvedValue(null),
+            getAllClientPresence: jest.fn().mockResolvedValue([
+                {
+                    clientId: 'client-1',
+                    address: 'tb1qworker',
+                    clientName: 'sv2gateway',
+                    sessionId: 'session',
+                    userAgent: 'unknown/sv2',
+                    startTime: '2026-01-01T00:00:00.000Z',
+                    lastSeen: '2026-01-01T00:00:10.000Z',
+                    hashRate: 123,
+                    bestDifficulty: 456,
+                },
+            ]),
+            setJsonCache: jest.fn().mockResolvedValue(undefined),
+            removeClientPresence: jest.fn().mockResolvedValue(undefined),
+        };
+        const service = new UserAgentReportService(
+            userAgentReport as any,
+            clientRepository as any,
+            redisMessagingService as any,
+        );
+
+        await expect(service.getReport()).resolves.toEqual([
+            {
+                userAgent: 'unknown/sv2',
+                count: '1',
+                bestDifficulty: 456,
+                totalHashRate: '123',
+            },
+        ]);
+        expect(userAgentReport.find).not.toHaveBeenCalled();
+    });
+
+    it('falls back to the materialized view in API-only processes when live presence is empty', async () => {
+        process.env.API_ONLY = 'true';
+        const viewRows = [
+            {
+                userAgent: 'db-view',
+                count: '1',
+                bestDifficulty: 0,
+                totalHashRate: '0',
+            },
+        ];
+        const userAgentReport = {
+            find: jest.fn().mockResolvedValue(viewRows),
+        };
+        const clientRepository = {
+            find: jest.fn().mockResolvedValue([]),
+        };
+        const redisMessagingService = {
+            getJsonCache: jest.fn().mockResolvedValue([]),
+            getAllClientPresence: jest.fn().mockResolvedValue([]),
+            setJsonCache: jest.fn().mockResolvedValue(undefined),
+            removeClientPresence: jest.fn().mockResolvedValue(undefined),
+        };
+        const service = new UserAgentReportService(
+            userAgentReport as any,
+            clientRepository as any,
+            redisMessagingService as any,
+        );
+
+        await expect(service.getReport()).resolves.toEqual(viewRows);
+    });
+
+    it('filters and removes stale Redis presence rows with no active database client', async () => {
+        process.env.API_ONLY = 'true';
+        const userAgentReport = {
+            find: jest.fn().mockResolvedValue([]),
+        };
+        const clientRepository = {
+            find: jest.fn().mockResolvedValue([{ id: 'active-client' }]),
+        };
+        const redisMessagingService = {
+            getJsonCache: jest.fn().mockResolvedValue(null),
+            getAllClientPresence: jest.fn().mockResolvedValue([
+                {
+                    clientId: 'active-client',
+                    address: 'tb1qactive',
+                    clientName: 'worker',
+                    sessionId: 'active',
+                    userAgent: 'bitaxe',
+                    startTime: '2026-01-01T00:00:00.000Z',
+                    lastSeen: '2026-01-01T00:00:10.000Z',
+                    hashRate: 100,
+                    bestDifficulty: 200,
+                },
+                {
+                    clientId: 'stale-client',
+                    address: 'tb1qstale',
+                    clientName: 'worker',
+                    sessionId: 'stale',
+                    userAgent: 'bitaxe',
+                    startTime: '2026-01-01T00:00:00.000Z',
+                    lastSeen: '2026-01-01T00:00:10.000Z',
+                    hashRate: 300,
+                    bestDifficulty: 400,
+                },
+            ]),
+            setJsonCache: jest.fn().mockResolvedValue(undefined),
+            removeClientPresence: jest.fn().mockResolvedValue(undefined),
+        };
+        const service = new UserAgentReportService(
+            userAgentReport as any,
+            clientRepository as any,
+            redisMessagingService as any,
+        );
+
+        await expect(service.getReport()).resolves.toEqual([
+            {
+                userAgent: 'bitaxe',
+                count: '1',
+                bestDifficulty: 200,
+                totalHashRate: '100',
+            },
+        ]);
+        expect(redisMessagingService.removeClientPresence)
+            .toHaveBeenCalledWith('stale-client', 'tb1qstale');
+    });
+});

src/ORM/_views/user-agent-report/user-agent-report.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { In, Repository } from 'typeorm';
 
 import { ClientEntity } from '../../client/client.entity';
 import { UserAgentReportView } from './user-agent-report.view';
@@ -29,10 +29,17 @@ export class UserAgentReportService {
                 return null;
             });
         if (cachedReport != null) {
-            return cachedReport;
+            if (cachedReport.length > 0) {
+                return cachedReport;
+            }
         }
 
         if (process.env.API_ONLY == 'true') {
+            const liveReport = await this.refreshLiveReport();
+            if (liveReport.length > 0) {
+                return liveReport;
+            }
+
             return await this.userAgentReport.find();
         }
 
@@ -54,6 +61,7 @@ export class UserAgentReportService {
 
     private async buildLiveReport() {
         const presences = await this.redisMessagingService.getAllClientPresence();
+        const activePresences = await this.filterActivePresences(presences);
         const rows = new Map<string, {
             userAgent: string;
             count: number;
@@ -61,7 +69,7 @@ export class UserAgentReportService {
             totalHashRate: number;
         }>();
 
-        presences.forEach(presence => {
+        activePresences.forEach(presence => {
             const userAgent = presence.userAgent == null || presence.userAgent.length === 0
                 ? 'Other'
                 : presence.userAgent;
@@ -98,6 +106,29 @@ export class UserAgentReportService {
         return report;
     }
 
+    private async filterActivePresences(presences: Awaited<ReturnType<RedisMessagingService['getAllClientPresence']>>) {
+        if (presences.length === 0) {
+            return [];
+        }
+
+        const activeClients = await this.clientRepository.find({
+            select: {
+                id: true,
+            },
+            where: {
+                id: In(presences.map(presence => presence.clientId)),
+            },
+        });
+        const activeIds = new Set(activeClients.map(client => client.id));
+        const stalePresences = presences.filter(presence => !activeIds.has(presence.clientId));
+        void Promise.all(stalePresences.map(presence => {
+            return this.redisMessagingService.removeClientPresence(presence.clientId, presence.address)
+                .catch(() => undefined);
+        }));
+
+        return presences.filter(presence => activeIds.has(presence.clientId));
+    }
+
     public async refreshReport() {
         try {
             await this.userAgentReport.query(`REFRESH MATERIALIZED VIEW user_agent_report_view`);