Migrate pool storage to TimescaleDB and Redis

2026-09-29 17:15:03 -07:00 · 2026-06-07 20:33:13 -04:00
parent fb367ac5f0
commit ec69f5fb6c
64 changed files with 4751 additions and 1146 deletions
@@ -1,20 +1,10 @@
 import { ConfigService } from '@nestjs/config';
-import { Test, TestingModule } from '@nestjs/testing';
-import { TypeOrmModule } from '@nestjs/typeorm';
 import { Socket } from 'net';
 import { BehaviorSubject } from 'rxjs';
-import { DataSource } from 'typeorm';

 import { MockRecording1 } from '../../test/models/MockRecording1';
-import { AddressSettingsModule } from '../ORM/address-settings/address-settings.module';
 import { AddressSettingsService } from '../ORM/address-settings/address-settings.service';
-import { BlocksEntity } from '../ORM/blocks/blocks.entity';
 import { BlocksService } from '../ORM/blocks/blocks.service';
-import { ClientStatisticsEntity } from '../ORM/client-statistics/client-statistics.entity';
-import { ClientStatisticsModule } from '../ORM/client-statistics/client-statistics.module';
-import { ClientStatisticsService } from '../ORM/client-statistics/client-statistics.service';
-import { ClientEntity } from '../ORM/client/client.entity';
-import { ClientModule } from '../ORM/client/client.module';
 import { ClientService } from '../ORM/client/client.service';
 import { BitcoinRpcService as MockBitcoinRpcService } from '../services/bitcoin-rpc.service';
 import { NotificationService } from '../services/notification.service';
@@ -45,10 +35,12 @@ describe('StratumV1Client', () => {
    let bitcoinRpcService: MockBitcoinRpcService;

    let clientService: ClientService;
-    let clientStatisticsService: ClientStatisticsService;
    let notificationService: NotificationService;
    let blocksService: BlocksService;
    let configService: ConfigService;
+    let addressSettings: AddressSettingsService;
+    let shareAccountingService: { recordAcceptedShare: jest.Mock };
+    let redisMessagingService: { setClientPresence: jest.Mock; removeClientPresence: jest.Mock };

    let client: StratumV1Client;

@@ -60,46 +52,6 @@ describe('StratumV1Client', () => {

    let newBlockEmitter: BehaviorSubject<IBlockTemplate> = new BehaviorSubject(MockRecording1.BLOCK_TEMPLATE);

-    let moduleRef: TestingModule;
-
-    beforeAll(async () => {
-        moduleRef = await Test.createTestingModule({
-            imports: [
-                TypeOrmModule.forRoot({
-                    type: 'better-sqlite3',
-                    database: ':memory:',
-                    synchronize: true,
-                    autoLoadEntities: true,
-                    cache: true,
-                    logging: false,
-                    entities: [ClientEntity, ClientStatisticsEntity, BlocksEntity]
-                }),
-                ClientModule,
-                ClientStatisticsModule,
-                AddressSettingsModule
-            ],
-            providers: [
-                {
-                    provide: ConfigService,
-                    useValue: {
-                        get: jest.fn((key: string) => {
-                            switch (key) {
-                                case 'DEV_FEE_ADDRESS':
-                                    return 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4';
-                                case 'NETWORK':
-                                    return 'testnet';
-                            }
-                            return null;
-                        })
-                    }
-                }
-            ],
-        }).compile();
-
-
-    })
-
-
    beforeEach(async () => {

        jest.useFakeTimers({ advanceTimers: true })
@@ -108,27 +60,38 @@ describe('StratumV1Client', () => {
        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);

-        clientService = moduleRef.get<ClientService>(ClientService);
+        const clients = new Map<string, any>();
+        let nextClientId = 1;
+        clientService = {
+            insert: jest.fn(async (partialClient) => {
+                const clientEntity = {
+                    id: `00000000-0000-4000-8000-${String(nextClientId++).padStart(12, '0')}`,
+                    hashRate: 0,
+                    updatedAt: new Date(),
+                    deletedAt: null,
+                    ...partialClient,
+                };
+                clients.set(clientEntity.id, clientEntity);
+                return clientEntity;
+            }),
+            delete: jest.fn(async (id: string) => {
+                clients.delete(id);
+            }),
+            connectedClientCount: jest.fn(async () => clients.size),
+            updateBestDifficultyIfHigher: jest.fn().mockResolvedValue({ affected: 1 }),
+        } as any;

-        const dataSource = moduleRef.get<DataSource>(DataSource);
-
-        await dataSource.getRepository(ClientStatisticsEntity).clear();
-        await dataSource.getRepository(ClientEntity).clear();
-        await dataSource.getRepository(BlocksEntity).clear();
-
-
-        clientStatisticsService = moduleRef.get<ClientStatisticsService>(ClientStatisticsService);
-
-        configService = moduleRef.get<ConfigService>(ConfigService);
-        (configService.get as jest.Mock).mockImplementation((key: string) => {
-            switch (key) {
-                case 'DEV_FEE_ADDRESS':
-                    return 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4';
-                case 'NETWORK':
-                    return 'testnet';
-            }
-            return null;
-        });
+        configService = {
+            get: jest.fn((key: string) => {
+                switch (key) {
+                    case 'DEV_FEE_ADDRESS':
+                        return 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4';
+                    case 'NETWORK':
+                        return 'testnet';
+                }
+                return null;
+            })
+        } as any;
        (StratumV1Client as any).blockedUserAgentLogState.clear();
        (StratumV1Client as any).validationErrorLogState.clear();

@@ -154,13 +117,24 @@ describe('StratumV1Client', () => {
        socket.end = jest.fn();
        jest.spyOn(socket, 'destroy').mockImplementation(() => socket);

-        const addressSettings = moduleRef.get<AddressSettingsService>(AddressSettingsService);
+        addressSettings = {
+            getSettings: jest.fn().mockResolvedValue(null),
+            updateBestDifficultyIfHigher: jest.fn().mockResolvedValue({ affected: 1 }),
+            resetBestDifficultyAndShares: jest.fn().mockResolvedValue(undefined),
+        } as any;
        notificationService = {
            notifySubscribersBlockFound: jest.fn().mockResolvedValue(undefined)
        } as any;
        blocksService = {
            save: jest.fn().mockResolvedValue(undefined)
        } as any;
+        shareAccountingService = {
+            recordAcceptedShare: jest.fn().mockResolvedValue(undefined),
+        };
+        redisMessagingService = {
+            setClientPresence: jest.fn().mockResolvedValue(undefined),
+            removeClientPresence: jest.fn().mockResolvedValue(undefined),
+        };


        client = new StratumV1Client(
@@ -168,11 +142,12 @@ describe('StratumV1Client', () => {
            stratumV1JobsService,
            bitcoinRpcService,
            clientService,
-            clientStatisticsService,
            notificationService,
            blocksService,
            configService,
-            addressSettings
+            addressSettings,
+            shareAccountingService as any,
+            redisMessagingService as any
        );

        client.extraNonceAndSessionId = MockRecording1.EXTRA_NONCE;
@@ -263,11 +238,10 @@ describe('StratumV1Client', () => {
            stratumV1JobsService,
            bitcoinRpcService,
            clientService,
-            clientStatisticsService,
            notificationService,
            blocksService,
            configService,
-            moduleRef.get<AddressSettingsService>(AddressSettingsService)
+            addressSettings
        );

        socketEmitter(Buffer.from(`{"id":1,"method":"mining.subscribe","params":["NMMiner/1.0"]}\n`));
@@ -369,6 +343,21 @@ describe('StratumV1Client', () => {
        await new Promise((r) => setTimeout(r, 1000));

        expect((client as any).write).lastCalledWith(`{\"id\":5,\"error\":null,\"result\":true}\n`);
+        expect(shareAccountingService.recordAcceptedShare).toHaveBeenCalledWith(expect.objectContaining({
+            protocol: 'sv1',
+            address: 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4',
+            clientName: 'bitaxe3',
+            sessionId: MockRecording1.EXTRA_NONCE,
+            jobId: '1',
+            jobTemplateId: '1',
+            creditedDifficulty: 0,
+            isBlockCandidate: false,
+        }));
+        expect(redisMessagingService.setClientPresence).toHaveBeenCalledWith(expect.objectContaining({
+            address: 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4',
+            clientName: 'bitaxe3',
+            sessionId: MockRecording1.EXTRA_NONCE,
+        }));


    });
@@ -423,7 +412,6 @@ describe('StratumV1Client', () => {
            submissionDifficulty: 1024,
            submissionHash: 'share'
        });
-        const addressSettings = moduleRef.get<AddressSettingsService>(AddressSettingsService);
        const getSettingsSpy = jest.spyOn(addressSettings, 'getSettings');
        const updateIfHigherSpy = jest.spyOn(addressSettings as any, 'updateBestDifficultyIfHigher').mockResolvedValue({ affected: 1 });
        const clientUpdateIfHigherSpy = jest.spyOn(clientService as any, 'updateBestDifficultyIfHigher').mockResolvedValue({ affected: 1 });
@@ -546,11 +534,10 @@ describe('StratumV1Client', () => {
            stratumV1JobsService,
            bitcoinRpcService,
            clientService,
-            clientStatisticsService,
            notificationService,
            blocksService,
            configService,
-            moduleRef.get<AddressSettingsService>(AddressSettingsService)
+            addressSettings
        );
        jest.spyOn(secondClient as any, 'write').mockImplementation((data) => Promise.resolve(true));
        jest.spyOn(secondClient as any, 'getRandomHexString').mockReturnValue(MockRecording1.EXTRA_NONCE);
@@ -580,7 +567,6 @@ describe('StratumV1Client', () => {
            submissionDifficulty: Number.MAX_SAFE_INTEGER,
            submissionHash: 'block-share'
        });
-        const addressSettings = moduleRef.get<AddressSettingsService>(AddressSettingsService);
        jest.spyOn(addressSettings, 'resetBestDifficultyAndShares').mockResolvedValue(undefined);

        emitMessage(MockRecording1.MINING_SUBSCRIBE);
@@ -9,11 +9,12 @@ import { clearInterval } from 'timers';

 import { AddressSettingsService } from '../ORM/address-settings/address-settings.service';
 import { BlocksService } from '../ORM/blocks/blocks.service';
-import { ClientStatisticsService } from '../ORM/client-statistics/client-statistics.service';
 import { ClientEntity } from '../ORM/client/client.entity';
 import { ClientService } from '../ORM/client/client.service';
+import { ShareAccountingService } from '../ORM/share-accounting/share-accounting.service';
 import { BitcoinRpcService } from '../services/bitcoin-rpc.service';
 import { NotificationService } from '../services/notification.service';
+import { RedisMessagingService } from '../services/redis-messaging.service';
 import { IJobTemplate, StratumV1JobsService } from '../services/stratum-v1-jobs.service';
 import { eRequestMethod } from './enums/eRequestMethod';
 import { eResponseMethod } from './enums/eResponseMethod';
@@ -67,11 +68,12 @@ export class StratumV1Client {
        private readonly stratumV1JobsService: StratumV1JobsService,
        private readonly bitcoinRpcService: BitcoinRpcService,
        private readonly clientService: ClientService,
-        private readonly clientStatisticsService: ClientStatisticsService,
        private readonly notificationService: NotificationService,
        private readonly blocksService: BlocksService,
        private readonly configService: ConfigService,
-        private readonly addressSettingsService: AddressSettingsService
+        private readonly addressSettingsService: AddressSettingsService,
+        private readonly shareAccountingService?: ShareAccountingService,
+        private readonly redisMessagingService?: RedisMessagingService
    ) {

        this.socket.on('data', (data: Buffer) => {
@@ -100,6 +102,7 @@ export class StratumV1Client {
    public async destroy() {

        if (this.clientEntity?.id) {
+            await this.redisMessagingService?.removeClientPresence(this.clientEntity.id, this.clientEntity.address);
            await this.clientService.delete(this.clientEntity.id);
        }

@@ -156,7 +159,7 @@ export class StratumV1Client {

                    if (this.sessionStart == null) {
                        this.sessionStart = new Date();
-                        this.statistics = new StratumV1ClientStatistics(this.clientStatisticsService);
+                        this.statistics = new StratumV1ClientStatistics();
                        this.extraNonceAndSessionId = this.getRandomHexString();
                        //console.log(`New client ID: : ${this.extraNonceAndSessionId}, ${this.socket.remoteAddress}:${this.socket.remotePort}`);
                    }
@@ -422,7 +425,6 @@ export class StratumV1Client {
        // //50Th/s
        // this.noFee = false;
        // if (this.clientEntity) {
-        //     this.hashRate = await this.clientStatisticsService.getHashRateForSession(this.clientEntity.id);
        //     // 250Gh/s
        //     if(this.hashRate < 250000000000){
        //         this.statistics.targetSubmitShareEveryNSeconds = 10;
@@ -491,12 +493,35 @@ export class StratumV1Client {
                    startTime: new Date(),
                    bestDifficulty: 0
                });
+                await this.updateClientPresence(new Date());
            })();
        }

        await this.creatingEntity;
    }

+    private async updateClientPresence(lastSeen: Date): Promise<void> {
+        if (this.clientEntity == null) {
+            return;
+        }
+
+        try {
+            await this.redisMessagingService?.setClientPresence({
+                clientId: this.clientEntity.id,
+                address: this.clientEntity.address,
+                clientName: this.clientEntity.clientName,
+                sessionId: this.clientEntity.sessionId,
+                userAgent: this.clientEntity.userAgent,
+                startTime: new Date(this.clientEntity.startTime).toISOString(),
+                lastSeen: lastSeen.toISOString(),
+                hashRate: this.statistics?.hashRate ?? 0,
+                bestDifficulty: Number(this.clientEntity.bestDifficulty ?? 0),
+            });
+        } catch (error) {
+            console.error(`Failed to update SV1 client presence: ${error.message}`);
+        }
+    }
+
    private async handleMiningSubmission(submission: MiningSubmitMessage) {

        const job = this.stratumV1JobsService.getJobById(submission.jobId);
@@ -574,6 +599,7 @@ export class StratumV1Client {
                return false;
            }

+            let blockSubmissionResult: string = null;
            if (submissionDifficulty >= jobTemplate.blockData.networkDifficulty) {
                console.log('!!! BLOCK FOUND !!!');
                const updatedJobBlock = job.copyAndUpdateBlock(
@@ -585,7 +611,7 @@ export class StratumV1Client {
                    timestamp
                );
                const blockHex = updatedJobBlock.toHex(false);
-                const result = await this.bitcoinRpcService.SUBMIT_BLOCK(blockHex);
+                blockSubmissionResult = await this.bitcoinRpcService.SUBMIT_BLOCK(blockHex);
                await this.blocksService.save({
                    height: jobTemplate.blockData.height,
                    minerAddress: this.clientAuthorization.address,
@@ -594,21 +620,40 @@ export class StratumV1Client {
                    blockData: blockHex
                });

-                await this.notificationService.notifySubscribersBlockFound(this.clientAuthorization.address, jobTemplate.blockData.height, updatedJobBlock, result);
+                await this.notificationService.notifySubscribersBlockFound(this.clientAuthorization.address, jobTemplate.blockData.height, updatedJobBlock, blockSubmissionResult);
                //success
-                if (result == null) {
+                if (blockSubmissionResult == null) {
                    await this.addressSettingsService.resetBestDifficultyAndShares();
                }
            }
            await this.ensureClientEntity();
            try {
+                await this.shareAccountingService?.recordAcceptedShare({
+                    protocol: 'sv1',
+                    address: this.clientAuthorization.address,
+                    clientName: this.clientAuthorization.worker,
+                    sessionId: this.extraNonceAndSessionId,
+                    clientId: this.clientEntity.id,
+                    jobId: job.jobId,
+                    jobTemplateId: job.jobTemplateId,
+                    blockHeight: jobTemplate.blockData.height,
+                    creditedDifficulty: this.sessionDifficulty,
+                    submissionDifficulty,
+                    networkDifficulty: jobTemplate.blockData.networkDifficulty,
+                    nonce: submission.nonce,
+                    ntime: submission.ntime,
+                    version: Number.isFinite(versionMask)
+                        ? (jobTemplate.block.version ^ versionMask).toString(16)
+                        : jobTemplate.block.version.toString(16),
+                    extraNonce2: submission.extraNonce2,
+                    isBlockCandidate: submissionDifficulty >= jobTemplate.blockData.networkDifficulty,
+                    blockSubmissionResult,
+                });
                await this.statistics.addShares(this.clientEntity, this.sessionDifficulty);
                const now = new Date();
-                // only update every minute
-                //if (this.clientEntity.updatedAt == null || now.getTime() - this.clientEntity.updatedAt.getTime() > 1000 * 60) {
-                this.clientService.heartbeatBulkAsync(this.clientEntity.id, this.statistics.hashRate, now);
                this.clientEntity.updatedAt = now;
-                //}
+                this.clientEntity.hashRate = this.statistics.hashRate;
+                await this.updateClientPresence(now);

            } catch (e) {
                console.log(e);
@@ -618,6 +663,7 @@ export class StratumV1Client {
                await this.clientService.updateBestDifficultyIfHigher(this.clientEntity.id, submissionDifficulty);
                this.clientEntity.bestDifficulty = submissionDifficulty;
                await this.addressSettingsService.updateBestDifficultyIfHigher(this.clientAuthorization.address, submissionDifficulty, this.clientEntity.userAgent);
+                await this.updateClientPresence(new Date());
            }


@@ -8,73 +8,31 @@ describe('StratumV1ClientStatistics', () => {
        sessionId: '57a6f098'
    } as any;

-    let clientStatisticsService: {
-        insert: jest.Mock,
-        updateBulkAsync: jest.Mock
-    };
    let statistics: StratumV1ClientStatistics;

    beforeEach(() => {
        jest.useFakeTimers();
        jest.setSystemTime(new Date('2026-05-06T12:00:00Z'));
-        clientStatisticsService = {
-            insert: jest.fn().mockResolvedValue(undefined),
-            updateBulkAsync: jest.fn().mockResolvedValue(undefined)
-        };
-        statistics = new StratumV1ClientStatistics(clientStatisticsService as any);
+        statistics = new StratumV1ClientStatistics();
    });

    afterEach(() => {
        jest.useRealTimers();
    });

-    it('should insert the first share bucket', async () => {
+    it('should keep runtime hashrate at zero before enough time passes', async () => {
        await statistics.addShares(client, 64);

-        expect(clientStatisticsService.insert).toHaveBeenCalledWith({
-            time: new Date('2026-05-06T12:00:00Z').getTime(),
-            clientId: client.id,
-            shares: 64,
-            acceptedCount: 1,
-            address: client.address,
-            clientName: client.clientName,
-            sessionId: client.sessionId
-        });
+        expect(statistics.hashRate).toBe(0);
    });

-    it('should update the current share bucket for additional shares', async () => {
-        await statistics.addShares(client, 64);
-        await statistics.addShares(client, 32);
+    it('should update runtime hashrate from accepted shares', async () => {
+        for (let i = 0; i < 3; i++) {
+            jest.setSystemTime(new Date(Date.parse('2026-05-06T12:00:00Z') + (i * 31000)));
+            await statistics.addShares(client, 64);
+        }

-        expect(clientStatisticsService.updateBulkAsync).toHaveBeenCalledWith({
-            time: new Date('2026-05-06T12:00:00Z').getTime(),
-            clientId: client.id,
-            shares: 96,
-            acceptedCount: 2
-        });
-    });
-
-    it('should create a new share bucket when the time slot changes', async () => {
-        await statistics.addShares(client, 64);
-        jest.setSystemTime(new Date('2026-05-06T12:10:00Z'));
-
-        await statistics.addShares(client, 32);
-
-        expect(clientStatisticsService.updateBulkAsync).toHaveBeenCalledWith({
-            time: new Date('2026-05-06T12:00:00Z').getTime(),
-            clientId: client.id,
-            shares: 64,
-            acceptedCount: 1
-        });
-        expect(clientStatisticsService.insert).toHaveBeenLastCalledWith({
-            time: new Date('2026-05-06T12:10:00Z').getTime(),
-            clientId: client.id,
-            shares: 32,
-            acceptedCount: 1,
-            address: client.address,
-            clientName: client.clientName,
-            sessionId: client.sessionId
-        });
+        expect(statistics.hashRate).toBeGreaterThan(0);
    });

    it('should not suggest a difficulty change before enough time or shares have passed', () => {
@@ -1,4 +1,3 @@
-import { ClientStatisticsService } from '../ORM/client-statistics/client-statistics.service';
 import { ClientEntity } from '../ORM/client/client.entity';

 const CACHE_SIZE = 30;
@@ -8,31 +7,16 @@ export class StratumV1ClientStatistics {
    public targetSubmitShareEveryNSeconds: number = 30;
    public hashRate = 0;

-    private shares: number = 0;
-    private acceptedCount: number = 0;
-
    private submissionCacheStart: Date;
    private submissionCache: { time: Date, difficulty: number }[] = [];
    private submissionCacheDifficultySum = 0;

-    private currentTimeSlot: number = null;
-
-    constructor(
-        private readonly clientStatisticsService: ClientStatisticsService,
-    ) {
+    constructor() {
        this.submissionCacheStart = new Date();
    }

-
-
-    // We don't want to save them here because it can be DB intensive, instead do it every once in
-    // awhile with saveShares()
-    public async addShares(client: ClientEntity, targetDifficulty: number) {
-
-        // 10 min
-        var coeff = 1000 * 60 * 10;
+    public async addShares(_client: ClientEntity, targetDifficulty: number) {
        var date = new Date();
-        var timeSlot = new Date(Math.floor(date.getTime() / coeff) * coeff).getTime();

        if (this.submissionCache.length > CACHE_SIZE) {
            this.submissionCacheDifficultySum -= this.submissionCache[0].difficulty;
@@ -44,55 +28,6 @@ export class StratumV1ClientStatistics {
        });
        this.submissionCacheDifficultySum += targetDifficulty;

-        if (this.currentTimeSlot == null) {
-            // First record, insert it
-            this.currentTimeSlot = timeSlot;
-            this.shares += targetDifficulty;
-            this.acceptedCount++;
-            await this.clientStatisticsService.insert({
-                time: this.currentTimeSlot,
-                clientId: client.id,
-                shares: this.shares,
-                acceptedCount: this.acceptedCount,
-                address: client.address,
-                clientName: client.clientName,
-                sessionId: client.sessionId
-            });
-        } else if (this.currentTimeSlot != timeSlot) {
-            // Transitioning to a new time slot,
-            // First update the old time slot with the latest data
-            this.clientStatisticsService.updateBulkAsync({
-                time: this.currentTimeSlot,
-                clientId: client.id,
-                shares: this.shares,
-                acceptedCount: this.acceptedCount,
-            });
-            // Set the new time slot and add incoming shares then insert it
-            this.currentTimeSlot = timeSlot;
-            this.shares = targetDifficulty;
-            this.acceptedCount = 1
-            await this.clientStatisticsService.insert({
-                time: this.currentTimeSlot,
-                clientId: client.id,
-                shares: this.shares,
-                acceptedCount: this.acceptedCount,
-                address: client.address,
-                clientName: client.clientName,
-                sessionId: client.sessionId
-            });
-        } else {
-            // Accept the shares if none of the prior conditions are met,
-            // saving to memory for storing later
-            this.shares += targetDifficulty;
-            this.acceptedCount++;
-            this.clientStatisticsService.updateBulkAsync({
-                time: this.currentTimeSlot,
-                clientId: client.id,
-                shares: this.shares,
-                acceptedCount: this.acceptedCount,
-            });
-        }
-
        const time = new Date().getTime() - this.submissionCache[0].time.getTime();
        if(time > 60000 && this.submissionCache.length > 2) { 
            this.hashRate = (this.submissionCacheDifficultySum * 4294967296) / (time / 1000);
@@ -151,4 +86,4 @@ export class StratumV1ClientStatistics {
        return res;
    }

-}
+}
@@ -107,7 +107,51 @@ describe('StratumV2Client extended channels', () => {
        expect(error.errorCode).toBe('invalid-extranonce-size');
    });

-    async function createClient(): Promise<{ client: StratumV2Client; sentFrames: any[] }> {
+    it('records accepted SV2 shares before presence updates', async () => {
+        const { client, shareAccountingService, redisMessagingService, jobTemplate } = await createClient();
+        (client as any).address = 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4';
+        (client as any).workerName = 'worker';
+        (client as any).sessionId = 'sv2-session';
+        (client as any).userAgent = 'test/sv2';
+
+        await (client as any).recordAcceptedShare(
+            2048,
+            1024,
+            jobTemplate,
+            null,
+            {
+                jobId: '1',
+                nonce: 123,
+                ntime: parseInt(MockRecording1.TIME, 16),
+                version: jobTemplate.block.version,
+                extraNonce2: 'c708000000000000',
+            },
+        );
+
+        expect(shareAccountingService.recordAcceptedShare).toHaveBeenCalledWith(expect.objectContaining({
+            protocol: 'sv2',
+            address: 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4',
+            clientName: 'worker',
+            sessionId: 'sv2-session',
+            jobId: '1',
+            creditedDifficulty: 1024,
+            submissionDifficulty: 2048,
+            nonce: 123,
+            extraNonce2: 'c708000000000000',
+        }));
+        const accountingCallOrder = shareAccountingService.recordAcceptedShare.mock.invocationCallOrder[0];
+        const postAccountingPresenceUpdates = redisMessagingService.setClientPresence.mock.invocationCallOrder
+            .filter(callOrder => callOrder > accountingCallOrder);
+        expect(postAccountingPresenceUpdates.length).toBeGreaterThan(0);
+    });
+
+    async function createClient(): Promise<{
+        client: StratumV2Client;
+        sentFrames: any[];
+        shareAccountingService: { recordAcceptedShare: jest.Mock };
+        redisMessagingService: { setClientPresence: jest.Mock; removeClientPresence: jest.Mock };
+        jobTemplate: any;
+    }> {
        const blockTemplate$ = new BehaviorSubject(MockRecording1.BLOCK_TEMPLATE);
        const bitcoinRpcService = {
            newBlockTemplate$: blockTemplate$.asObservable(),
@@ -115,7 +159,7 @@ describe('StratumV2Client extended channels', () => {
            SUBMIT_BLOCK: jest.fn().mockResolvedValue(null),
        };
        const stratumV1JobsService = new StratumV1JobsService(bitcoinRpcService as any);
-        await firstValueFrom(stratumV1JobsService.newMiningJob$);
+        const jobTemplate = await firstValueFrom(stratumV1JobsService.newMiningJob$);

        const mockSocket: any = {
            destroyed: false,
@@ -138,11 +182,24 @@ describe('StratumV2Client extended channels', () => {
            address: 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4',
            clientName: 'worker',
            userAgent: 'test/sv2',
+            startTime: new Date(),
            bestDifficulty: 0,
        } as unknown as ClientEntity;

        let nextChannelId = 1;
        const sentFrames: any[] = [];
+        const clientService = {
+            insert: jest.fn().mockResolvedValue(clientEntity),
+            delete: jest.fn().mockResolvedValue(undefined),
+            updateBestDifficultyIfHigher: jest.fn().mockResolvedValue(undefined),
+        };
+        const shareAccountingService = {
+            recordAcceptedShare: jest.fn().mockResolvedValue(undefined),
+        };
+        const redisMessagingService = {
+            setClientPresence: jest.fn().mockResolvedValue(undefined),
+            removeClientPresence: jest.fn().mockResolvedValue(undefined),
+        };
        const client = new StratumV2Client(
            socket,
            Buffer.alloc(0),
@@ -167,16 +224,7 @@ describe('StratumV2Client extended channels', () => {
            } as any,
            stratumV1JobsService,
            bitcoinRpcService as any,
-            {
-                insert: jest.fn().mockResolvedValue(clientEntity),
-                delete: jest.fn().mockResolvedValue(undefined),
-                heartbeatBulkAsync: jest.fn(),
-                updateBestDifficultyIfHigher: jest.fn().mockResolvedValue(undefined),
-            } as any,
-            {
-                insert: jest.fn().mockResolvedValue(undefined),
-                updateBulkAsync: jest.fn(),
-            } as any,
+            clientService as any,
            { notifySubscribersBlockFound: jest.fn().mockResolvedValue(undefined) } as any,
            { save: jest.fn().mockResolvedValue(undefined) } as any,
            {
@@ -195,12 +243,14 @@ describe('StratumV2Client extended channels', () => {
                resetBestDifficultyAndShares: jest.fn().mockResolvedValue(undefined),
                updateBestDifficultyIfHigher: jest.fn().mockResolvedValue(undefined),
            } as any,
+            shareAccountingService as any,
+            redisMessagingService as any,
        );
        (client as any).sendFrame = jest.fn((msgType: number, payload: Buffer, extensionType = 0) => {
            sentFrames.push({ msgType, payload, extensionType });
            return Promise.resolve();
        });

-        return { client, sentFrames };
+        return { client, sentFrames, shareAccountingService, redisMessagingService, jobTemplate };
    }
 });
@@ -7,11 +7,12 @@ import { firstValueFrom, Subscription } from 'rxjs';

 import { AddressSettingsService } from '../ORM/address-settings/address-settings.service';
 import { BlocksService } from '../ORM/blocks/blocks.service';
-import { ClientStatisticsService } from '../ORM/client-statistics/client-statistics.service';
 import { ClientEntity } from '../ORM/client/client.entity';
 import { ClientService } from '../ORM/client/client.service';
+import { ShareAccountingService } from '../ORM/share-accounting/share-accounting.service';
 import { BitcoinRpcService } from '../services/bitcoin-rpc.service';
 import { NotificationService } from '../services/notification.service';
+import { RedisMessagingService } from '../services/redis-messaging.service';
 import { StratumV2Service } from '../services/stratum-v2.service';
 import { IJobTemplate, StratumV1JobsService } from '../services/stratum-v1-jobs.service';
 import { patchCoinbasePrefixVarint } from '../utils/coinbase-prefix.utils';
@@ -128,18 +129,19 @@ export class StratumV2Client {
        private readonly stratumV1JobsService: StratumV1JobsService,
        private readonly bitcoinRpcService: BitcoinRpcService,
        private readonly clientService: ClientService,
-        private readonly clientStatisticsService: ClientStatisticsService,
        private readonly notificationService: NotificationService,
        private readonly blocksService: BlocksService,
        private readonly configService: ConfigService,
        private readonly addressSettingsService: AddressSettingsService,
+        private readonly shareAccountingService?: ShareAccountingService,
+        private readonly redisMessagingService?: RedisMessagingService,
    ) {
        this.firstChunkSummary = this.describeChunk(firstChunk);
        this.noiseSession = new Sv2NoiseSession(this.stratumV2Service.getNoiseConfig());
        this.sessionDifficulty = this.getInitialDifficulty();
        this.targetSharesPerMinute = this.getTargetSharesPerMinute();
        this.difficultyCheckIntervalMs = this.getDifficultyCheckIntervalMs();
-        this.statistics = new StratumV1ClientStatistics(this.clientStatisticsService);
+        this.statistics = new StratumV1ClientStatistics();
        this.statistics.targetSubmitShareEveryNSeconds = 60 / this.targetSharesPerMinute;
        this.network = this.getNetwork();

@@ -171,6 +173,7 @@ export class StratumV2Client {
        }
        this.channels.clear();
        if (this.clientEntity?.id != null) {
+            await this.redisMessagingService?.removeClientPresence(this.clientEntity.id, this.clientEntity.address);
            await this.clientService.delete(this.clientEntity.id);
        }
    }
@@ -647,7 +650,13 @@ export class StratumV2Client {
        if (submissionDifficulty >= extendedJob.jobTemplate.blockData.networkDifficulty) {
            updatedJobBlock = this.reconstructExtendedBlock(extendedJob, submission, merkleRoot, channel.extranoncePrefix);
        }
-        await this.recordAcceptedShare(submissionDifficulty, jobDifficulty, extendedJob.jobTemplate, updatedJobBlock);
+        await this.recordAcceptedShare(submissionDifficulty, jobDifficulty, extendedJob.jobTemplate, updatedJobBlock, {
+            jobId: submission.jobId.toString(16),
+            nonce: submission.nonce,
+            ntime: submission.ntime,
+            version: submission.version,
+            extraNonce2: submission.extranonce.toString('hex'),
+        });
    }

    private async handleAcceptedShare(
@@ -671,7 +680,13 @@ export class StratumV2Client {
            );
        }

-        await this.recordAcceptedShare(submissionDifficulty, jobDifficulty, jobTemplate, updatedJobBlock);
+        await this.recordAcceptedShare(submissionDifficulty, jobDifficulty, jobTemplate, updatedJobBlock, {
+            jobId: job.jobId,
+            nonce: submission.nonce,
+            ntime: submission.ntime,
+            version: submission.version,
+            extraNonce2: FIXED_STANDARD_EXTRANONCE2,
+        });
    }

    private async recordAcceptedShare(
@@ -679,13 +694,15 @@ export class StratumV2Client {
        jobDifficulty: number,
        jobTemplate: IJobTemplate,
        updatedJobBlock: bitcoinjs.Block | null,
+        share: { jobId: string; nonce: number; ntime: number; version: number; extraNonce2: string },
    ): Promise<void> {
        await this.ensureClientEntity();

+        let blockSubmissionResult: string = null;
        if (updatedJobBlock != null) {
            console.log(`[SV2 ${this.sessionId}] BLOCK FOUND at height ${jobTemplate.blockData.height}`);
            const blockHex = updatedJobBlock.toHex(false);
-            const result = await this.bitcoinRpcService.SUBMIT_BLOCK(blockHex);
+            blockSubmissionResult = await this.bitcoinRpcService.SUBMIT_BLOCK(blockHex);
            await this.blocksService.save({
                height: jobTemplate.blockData.height,
                minerAddress: this.address,
@@ -697,17 +714,37 @@ export class StratumV2Client {
                this.address,
                jobTemplate.blockData.height,
                updatedJobBlock,
-                result,
+                blockSubmissionResult,
            );
-            if (result == null) {
+            if (blockSubmissionResult == null) {
                await this.addressSettingsService.resetBestDifficultyAndShares();
            }
        }

+        await this.shareAccountingService?.recordAcceptedShare({
+            protocol: 'sv2',
+            address: this.address,
+            clientName: this.workerName,
+            sessionId: this.sessionId,
+            clientId: this.clientEntity.id,
+            jobId: share.jobId,
+            jobTemplateId: jobTemplate.blockData.id,
+            blockHeight: jobTemplate.blockData.height,
+            creditedDifficulty: jobDifficulty,
+            submissionDifficulty,
+            networkDifficulty: jobTemplate.blockData.networkDifficulty,
+            nonce: share.nonce,
+            ntime: share.ntime,
+            version: share.version,
+            extraNonce2: share.extraNonce2,
+            isBlockCandidate: updatedJobBlock != null,
+            blockSubmissionResult,
+        });
        await this.statistics.addShares(this.clientEntity, jobDifficulty);
        const now = new Date();
-        this.clientService.heartbeatBulkAsync(this.clientEntity.id, this.statistics.hashRate, now);
        this.clientEntity.updatedAt = now;
+        this.clientEntity.hashRate = this.statistics.hashRate;
+        await this.updateClientPresence(now);

        if (submissionDifficulty > this.clientEntity.bestDifficulty) {
            await this.clientService.updateBestDifficultyIfHigher(this.clientEntity.id, submissionDifficulty);
@@ -717,6 +754,7 @@ export class StratumV2Client {
                submissionDifficulty,
                this.userAgent,
            );
+            await this.updateClientPresence(new Date());
        }
    }

@@ -1085,12 +1123,35 @@ export class StratumV2Client {
                    startTime: new Date(),
                    bestDifficulty: 0,
                });
+                await this.updateClientPresence(new Date());
            })();
        }

        await this.creatingEntity;
    }

+    private async updateClientPresence(lastSeen: Date): Promise<void> {
+        if (this.clientEntity == null) {
+            return;
+        }
+
+        try {
+            await this.redisMessagingService?.setClientPresence({
+                clientId: this.clientEntity.id,
+                address: this.clientEntity.address,
+                clientName: this.clientEntity.clientName,
+                sessionId: this.clientEntity.sessionId,
+                userAgent: this.clientEntity.userAgent,
+                startTime: new Date(this.clientEntity.startTime).toISOString(),
+                lastSeen: lastSeen.toISOString(),
+                hashRate: this.statistics.hashRate,
+                bestDifficulty: Number(this.clientEntity.bestDifficulty ?? 0),
+            });
+        } catch (error) {
+            console.error(`Failed to update SV2 client presence: ${error.message}`);
+        }
+    }
+
    private parseUserIdentity(userIdentity: string): { address: string; workerName: string } {
        const parts = userIdentity.split('.');
        const rawAddress = parts[0] ?? '';