blurifycom · zaxovaiko · Sep 25, 2026 · Sep 24, 2026 · Sep 25, 2026 · Sep 25, 2026
@@ -294,6 +294,11 @@
       "import": "./dist/engagement/notifications/contract/index.js",
       "default": "./dist/engagement/notifications/contract/index.js"
     },
+    "./engagement/notifications": {
+      "types": "./dist/engagement/notifications/index.d.ts",
+      "import": "./dist/engagement/notifications/index.js",
+      "default": "./dist/engagement/notifications/index.js"
+    },
     "./engagement/schema/chat": {
       "types": "./dist/engagement/chat/schema/index.d.ts",
       "import": "./dist/engagement/chat/schema/index.js",

@@ -1018,6 +1018,49 @@ describe('GamingService.startRound wallet.balance.changed event (real PG)', () =
 
     expect(events.emit).not.toHaveBeenCalledWith('wallet.balance.changed', expect.anything());
   });
+
+  it('also emits it for a WAGER_TRACKING credit (rank rakeback) alongside the bet debit', async () => {
+    const created = await seedGame({ id: '00000000-0000-0000-0000-0000000000a8', name: 'Aces' });
+    const events = makeEventBus();
+    const walletCommands = makeWalletCommands({
+      ok: true,
+      moved: true,
+      newBalance: '90',
+      currency: 'USD',
+      transactionId: '00000000-0000-0000-0000-0000000000d2',
+      wagerTrackingCredits: [
+        {
+          transactionId: '00000000-0000-0000-0000-0000000000d3',
+          amount: '0.10',
+          currency: 'USD',
+        },
+      ],
+    });
+    const svc = new GamingService(
+      db.drizzle,
+      events,
+      mock<GameAdapter>({
+        launchGame: vi.fn().mockResolvedValue({ launchUrl: 'https://mock/play', token: 'tok' }),
+        endRound: vi.fn(),
+      }),
+      unrestricted,
+      walletCommands,
+      makeIdentityReader(),
+    );
+    const userId = '00000000-0000-0000-0000-000000000408';
+
+    await startRound(svc, userId, created.id, 'USD', '10');
+
+    expect(events.emit).toHaveBeenCalledWith('wallet.balance.changed', {
+      userId,
+      playerId: null,
+      amount: '0.10',
+      currency: 'USD',
+      transactionId: '00000000-0000-0000-0000-0000000000d3',
+      type: 'cashback',
+      direction: 'credit',
+    });
+  });
 });
 
 describe('GamingService updateGame (real PG)', () => {

@@ -558,47 +558,49 @@ export class GamingService {
     // without one can never be settled back.
     const roundId = randomUUID();
 
-    const { round, betTransactionId, completed } = await this.drizzle.db.transaction(async (tx) => {
-      // The same currency the RG pre-check above weighed. Left off, the debit falls on the
-      // player's active currency, and the two would then judge different moves.
-      const outcome = await this.walletCommands.debit(tx, {
-        userId,
-        amount: betAmount,
-        currency,
-        type: 'bet',
-        context: { provider: INTERNAL_ROUND_PROVIDER, product: INTERNAL_ROUND_PRODUCT, gameId },
-        providerRef: {
-          providerName: INTERNAL_ROUND_PROVIDER,
-          providerRefId: `bet:${roundId}`,
-          externalRoundId: roundId,
-        },
+    const { round, betTransactionId, completed, wagerTrackingCredits } =
+      await this.drizzle.db.transaction(async (tx) => {
+        // The same currency the RG pre-check above weighed. Left off, the debit falls on the
+        // player's active currency, and the two would then judge different moves.
+        const outcome = await this.walletCommands.debit(tx, {
+          userId,
+          amount: betAmount,
+          currency,
+          type: 'bet',
+          context: { provider: INTERNAL_ROUND_PROVIDER, product: INTERNAL_ROUND_PRODUCT, gameId },
+          providerRef: {
+            providerName: INTERNAL_ROUND_PROVIDER,
+            providerRefId: `bet:${roundId}`,
+            externalRoundId: roundId,
+          },
+        });
+        if (!outcome.ok) {
+          throw new InsufficientBalanceError(outcome.available, betAmount);
+        }
+        const insertedRound = findOneOrThrow(
+          await tx
+            .insert(gameRound)
+            .values({
+              id: roundId,
+              gameId,
+              userId,
+              currency,
+              betAmount,
+              status: 'active',
+            })
+            .returning(),
+          new GameRoundNotFoundError(gameId),
+        );
+        const moved = outcome.moved ? outcome : undefined;
+        return {
+          round: insertedRound,
+          completed: moved?.completed
+            ? { ...moved.completed, currency: outcome.currency }
+            : undefined,
+          betTransactionId: moved?.transactionId,
+          wagerTrackingCredits: moved?.wagerTrackingCredits ?? [],
+        };
       });
-      if (!outcome.ok) {
-        throw new InsufficientBalanceError(outcome.available, betAmount);
-      }
-      const insertedRound = findOneOrThrow(
-        await tx
-          .insert(gameRound)
-          .values({
-            id: roundId,
-            gameId,
-            userId,
-            currency,
-            betAmount,
-            status: 'active',
-          })
-          .returning(),
-        new GameRoundNotFoundError(gameId),
-      );
-      const moved = outcome.moved ? outcome : undefined;
-      return {
-        round: insertedRound,
-        completed: moved?.completed
-          ? { ...moved.completed, currency: outcome.currency }
-          : undefined,
-        betTransactionId: moved?.transactionId,
-      };
-    });
 
     const playerId = await this.identityReader.getPlayerIdByUserIdSafe(userId);
 
@@ -616,6 +618,20 @@ export class GamingService {
       });
     }
 
+    // Whatever a WAGER_TRACKING consumer (rank rakeback) credited to the real balance inside the
+    // same transaction as the bet above - same post-commit rule as the bet debit itself.
+    for (const credit of wagerTrackingCredits) {
+      this.events.emit('wallet.balance.changed', {
+        userId,
+        playerId,
+        amount: credit.amount,
+        currency: credit.currency,
+        transactionId: credit.transactionId,
+        type: 'cashback',
+        direction: 'credit',
+      });
+    }
+
     // Post-commit: the money moved inside the transaction above, this only tells the player.
     if (completed) {
       this.events.emit('promo.bonus.completed', {

@@ -480,7 +480,7 @@ describe('KycVerificationService.handleDeposit - threshold re-KYC (real PG)', ()
     expect(statusWriter.setStatus).not.toHaveBeenCalled();
   });
 
-  it('ignores deposits in another currency than the player account', async () => {
+  it('skips evaluation (no report) when a deposit currency cannot be priced into the pivot', async () => {
     const { svc, statusWriter } = makeService({ config });
     const { userId } = await seedPlayer({ currency: 'EUR' });
     await seedDeposit(userId, '2000', 'EUR');
@@ -490,6 +490,24 @@ describe('KycVerificationService.handleDeposit - threshold re-KYC (real PG)', ()
     expect(statusWriter.setStatus).not.toHaveBeenCalled();
   });
 
+  it('fires for a player whose own currency differs from the pivot, once their deposits price past the threshold', async () => {
+    const rates = makeRates({ EUR: '1.1' });
+    const { svc, statusWriter } = makeService({ config, exchangeRateReader: rates });
+    const { userId } = await seedPlayer({ currency: 'EUR' });
+    await seedDeposit(userId, '1000', 'EUR');
+
+    await svc.handleDeposit(userId);
+
+    expect(statusWriter.setStatus).toHaveBeenCalledWith(
+      userId,
+      'resubmission_requested',
+      expect.objectContaining({ source: 'reverify' }),
+      expect.anything(),
+    );
+    const [row] = await verificationsOf(userId);
+    expect(Number(row?.triggerDeposits)).toBe(1100);
+  });
+
   it('ignores a pending deposit that has not settled', async () => {
     const { svc, statusWriter } = makeService({ config });
     const { userId } = await seedPlayer();

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from 'vitest';
 import { randomUUID } from 'node:crypto';
-import { eq, sql } from 'drizzle-orm';
+import { and, eq, sql } from 'drizzle-orm';
 import type {
   ExchangeRateReader,
   LoginEnforcementPort,
@@ -22,7 +22,7 @@ import { player } from '@openora/core/pam/schema/profile';
 import { makeIdentityReader, mock, makeEventBus } from '../../testing/mock.js';
 import { migrate } from '../migrate.js';
 import { userLimit, rgExclusion, rgFlag } from '../schema/index.js';
-import { RgService } from '../service/rg.service.js';
+import { RgService, LimitOrderingViolationError } from '../service/rg.service.js';
 import { RgMonitoringService } from '../service/rg-monitoring.service.js';
 import {
   RgSelfServiceService,
@@ -249,6 +249,68 @@ describe('RgSelfServiceService.upsertLimit (real PG)', () => {
   });
 });
 
+describe('RgSelfServiceService.upsertLimit ordering (real PG)', () => {
+  it('refuses an immediate write (a lowering) that would cross an existing sibling bound', async () => {
+    const { svc } = makeService();
+    const userId = randomUUID();
+    await svc.upsertLimit(userId, { ...deposit100, period: 'weekly', amount: '50' });
+
+    // A first-time daily write is immediate, and 80 > the weekly bound of 50.
+    await expect(
+      svc.upsertLimit(userId, { ...deposit100, period: 'daily', amount: '80' }),
+    ).rejects.toBeInstanceOf(LimitOrderingViolationError);
+  });
+
+  it('refuses a parked raise whose pending (effective) amount would cross an existing sibling bound', async () => {
+    const { svc } = makeService();
+    const userId = randomUUID();
+    await svc.upsertLimit(userId, { ...deposit100, period: 'daily', amount: '10' });
+    await svc.upsertLimit(userId, { ...deposit100, period: 'weekly', amount: '20' });
+
+    // A raise on daily to 30 is parked (not applied), but 30 already exceeds the
+    // existing weekly=20 - it must be refused now, using the pending value.
+    await expect(
+      svc.upsertLimit(userId, { ...deposit100, period: 'daily', amount: '30' }),
+    ).rejects.toBeInstanceOf(LimitOrderingViolationError);
+
+    const rows = await db.drizzle.db
+      .select()
+      .from(userLimit)
+      .where(and(eq(userLimit.userId, userId), eq(userLimit.period, 'daily')));
+    expect(rows[0]?.pendingKind).toBeNull();
+  });
+
+  it('accepts a valid ordered set across daily/weekly/monthly', async () => {
+    const { svc } = makeService();
+    const userId = randomUUID();
+    await svc.upsertLimit(userId, { ...deposit100, period: 'daily', amount: '10' });
+    await svc.upsertLimit(userId, { ...deposit100, period: 'weekly', amount: '20' });
+    const view = await svc.upsertLimit(userId, { ...deposit100, period: 'monthly', amount: '30' });
+
+    expect(view.amount).toBe('30.000000000000000000');
+  });
+
+  it('refuses when a required cross-currency rate is missing, rather than skipping the check', async () => {
+    const { svc } = makeService();
+    const userId = randomUUID();
+    await svc.upsertLimit(userId, {
+      ...deposit100,
+      period: 'daily',
+      amount: '10',
+      currency: 'USD',
+    });
+
+    await expect(
+      svc.upsertLimit(userId, {
+        ...deposit100,
+        period: 'weekly',
+        amount: '20',
+        currency: 'EUR',
+      }),
+    ).rejects.toBeInstanceOf(LimitOrderingViolationError);
+  });
+});
+
 const BTC_USD_RATE = 50000;
 
 describe('RgSelfServiceService.getLimits - multi-currency usage', () => {
@@ -346,6 +408,22 @@ describe('RgSelfServiceService.requestLimitRemoval (real PG)', () => {
       LimitOwnershipError,
     );
   });
+
+  it('is never blocked by ordering - removing a bound only loosens it', async () => {
+    const { svc } = makeService();
+    const userId = randomUUID();
+    await svc.upsertLimit(userId, { ...deposit100, period: 'daily', amount: '20' });
+    await svc.upsertLimit(userId, { ...deposit100, period: 'weekly', amount: '20' });
+    const rows = await db.drizzle.db
+      .select()
+      .from(userLimit)
+      .where(and(eq(userLimit.userId, userId), eq(userLimit.period, 'weekly')));
+    const weeklyRow = rows[0]!;
+
+    const view = await svc.requestLimitRemoval(weeklyRow.id, userId);
+
+    expect(view.pendingKind).toBe('removal');
+  });
 });
 
 describe('RgSelfServiceService.confirmPendingChange (real PG)', () => {