@openora/core 0.4.1-canary.37 → 0.4.1-canary.39

package/dist/wallet/__tests__/wallet-auto-withdrawal.test.js

@@ -1,581 +1,558 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { mock, readPrivate, makeDrizzle, makeEvents, makePayment, NO_CLIENT_META, } from '../../testing/mock.js';
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from 'vitest';
+import { randomUUID } from 'node:crypto';
+import { eq, sql } from 'drizzle-orm';
+import { createTestDb } from '@openora/core/testing';
+import { mock, makeEventBus, NO_CLIENT_META, makeAuditWriter } from '../../testing/mock.js';
+import { migrate } from '../migrate.js';
+import { wallet, walletTransaction, autoWithdrawalRule } from '../schema/index.js';
 import { WalletService } from '../service/wallet.service.js';
-const makeAudit = () => ({ record: vi.fn().mockResolvedValue(undefined) });
-const WALLET_ROW = { id: 'w-1', userId: 'u-1', balance: '100000', currency: 'USD' };
-const insertRow = (over = {}) => ({
-    id: 'tx-1',
-    walletId: 'w-1',
-    amount: '40',
-    currency: 'USD',
-    status: 'pending',
-    rail: 'fiat',
-    ...over,
-});
-// select/returning rows the initial hold transaction always consumes (no idempotency key).
-const holdSelect = (wallet = WALLET_ROW) => [wallet];
-const holdReturning = (tx = insertRow()) => [[tx], [{ id: 'w-1' }]];
-// select/returning rows the flipToProcessing + settleApproved path consumes on a successful settle.
-const finalizeSelect = () => [
-    [
-        {
-            id: 'tx-1',
-            walletId: 'w-1',
-            type: 'withdrawal',
-            status: 'pending',
-            amount: '40',
-            currency: 'USD',
-        },
-    ],
-    [{ userId: 'u-1' }],
-    [],
-];
-const finalizeReturning = () => [
-    [
-        {
-            id: 'tx-1',
-            walletId: 'w-1',
-            type: 'withdrawal',
-            status: 'processing',
-            amount: '40',
-            currency: 'USD',
-            rail: 'fiat',
-        },
-    ],
-];
-function makeSvc(opts) {
-    const events = makeEvents();
-    const payment = makePayment();
-    const audit = makeAudit();
-    const platformConfig = {
-        ...(opts.kyc ? { kyc: opts.kyc } : {}),
-        ...(opts.autoWithdrawal
-            ? { autoWithdrawal: { enabled: true, excludeRiskFlags: [], ...opts.autoWithdrawal } }
-            : {}),
+let db;
+function makeService({ autoWithdrawal, kycStatus = 'verified', directoryThrows = false, riskTags = [], } = {}) {
+    const events = makeEventBus();
+    const psp = {
+        processWithdrawal: vi.fn(async () => ({
+            externalId: randomUUID(),
+            status: 'completed',
+        })),
     };
-    const svc = new WalletService(mock({
-        drizzle: opts.drizzle,
-        events,
-        payment,
-        directory: opts.directory,
-        riskTags: opts.riskTags,
-        audit,
+    const audit = makeAuditWriter();
+    const directory = mock({
+        lookupPlayers: vi.fn(async (ids) => {
+            if (directoryThrows) {
+                throw new Error('directory down');
+            }
+            return kycStatus
+                ? ids.map((userId) => mock({ userId, username: 'player', kycStatus }))
+                : [];
+        }),
+    });
+    const platformConfig = mock(autoWithdrawal
+        ? { autoWithdrawal: { enabled: true, excludeRiskFlags: [], ...autoWithdrawal } }
+        : {});
+    const svc = new WalletService({
+        drizzle: db.drizzle,
+        events: events,
+        payment: mock(psp),
+        audit: mock(audit),
+        directory,
         platformConfig,
-    }));
-    return { svc, events, payment, audit };
+        ...(riskTags === 'unbound'
+            ? {}
+            : {
+                riskTags: mock({
+                    getActiveTagKeys: vi.fn(async (ids) => new Map(ids.map((id) => [id, riskTags]))),
+                }),
+            }),
+    });
+    return { svc, events, psp, audit };
+}
+async function seedWallet(overrides = {}) {
+    const [row] = await db.drizzle.db
+        .insert(wallet)
+        .values({ userId: randomUUID(), balance: '100000', currency: 'USD', ...overrides })
+        .returning();
+    return row;
+}
+async function txById(id) {
+    const [row] = await db.drizzle.db
+        .select()
+        .from(walletTransaction)
+        .where(eq(walletTransaction.id, id));
+    return row;
 }
-const verifiedDirectory = () => ({
-    lookupPlayers: vi.fn().mockResolvedValue([{ userId: 'u-1', kycStatus: 'verified' }]),
+beforeAll(async () => {
+    db = await createTestDb([migrate]);
 });
-describe('WalletService.withdraw auto-approval', () => {
-    beforeEach(() => vi.clearAllMocks());
-    it('auto-approves a fiat withdrawal that passes every gate, reusing the approve/settle path', async () => {
-        const dz = makeDrizzle({
-            select: [
-                ...holdSelect().map((r) => [r]),
-                [], // resolveAutoThreshold: no per-player rule -> falls back to global (pre-lock)
-                [{ walletId: 'w-1', n: 1 }], // velocity grouped count (< 3), pre-lock
-                [{ total: '0', n: 0 }], // caps, inside the advisory lock
-                ...finalizeSelect(),
-            ],
-            returning: [...holdReturning(), ...finalizeReturning()],
-        });
-        const setSpy = readPrivate(dz.db, 'set');
-        const { svc, payment, audit } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000' },
-        });
+afterAll(async () => {
+    await db.drop();
+});
+beforeEach(async () => {
+    await db.drizzle.db.execute(sql `TRUNCATE ${walletTransaction}, ${autoWithdrawalRule}, ${wallet} RESTART IDENTITY CASCADE`);
+});
+describe('WalletService.withdraw auto-approval (real PG)', () => {
+    it('auto-approves a fiat withdrawal that clears every gate, marking the system as reviewer', async () => {
+        const { svc, psp, audit, events } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
-        expect(result).toEqual({ transactionId: 'tx-1', status: 'completed' });
-        expect(payment.processWithdrawal).toHaveBeenCalledTimes(1);
-        expect(setSpy).toHaveBeenCalledWith(expect.objectContaining({ reviewReason: 'auto-approved', reviewedBy: null }));
-        expect(setSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'completed', providerRefId: 'ext-2' }));
+        expect(result.status).toBe('completed');
+        expect(psp.processWithdrawal).toHaveBeenCalledTimes(1);
+        expect(await txById(result.transactionId)).toMatchObject({
+            status: 'completed',
+            reviewedBy: null,
+            reviewReason: 'auto-approved',
+            providerName: 'psp',
+        });
+        expect(events.emit.mock.calls.map(([topic]) => topic)).toEqual([
+            'wallet.withdrawal.requested',
+            'wallet.withdrawal.completed',
+        ]);
         expect(audit.record).toHaveBeenCalledWith(expect.objectContaining({
             actorType: 'system',
             action: 'wallet.withdrawal.auto_approved',
             resourceType: 'wallet_transaction',
-            resourceId: 'tx-1',
+            resourceId: result.transactionId,
             after: expect.objectContaining({
                 threshold: '1000',
                 thresholdSource: 'global',
                 kycStatus: 'verified',
-                riskTagsEvaluated: [],
+                cumulativeCountUsed: 0,
             }),
         }));
     });
-    it('takes a per-user advisory lock before the cap check + auto-approval flip', async () => {
-        // The mock can't reproduce advisory-lock serialization, so instead prove the invariant it relies on:
-        // pg_advisory_xact_lock is acquired before the flip that writes the marker the next caller's cap query reads.
-        const dz = makeDrizzle({
-            select: [
-                ...holdSelect().map((r) => [r]),
-                [], // resolveAutoThreshold -> global fallback
-                [{ n: 1 }], // velocity
-                [{ total: '0', n: 0 }], // caps
-                ...finalizeSelect(),
-            ],
-            returning: [...holdReturning(), ...finalizeReturning()],
-        });
-        const setSpy = readPrivate(dz.db, 'set');
-        const executeSpy = readPrivate(dz.db, 'execute');
-        const { svc } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000', dailyCapCount: 1 },
-        });
-        await svc.withdraw({ userId: 'u-1', amount: '40', currency: 'USD', ...NO_CLIENT_META });
-        expect(executeSpy).toHaveBeenCalledTimes(1);
-        const lockOrder = executeSpy.mock.invocationCallOrder.at(0);
-        if (lockOrder === undefined) {
-            throw new Error('expected executeSpy to have been called');
-        }
-        // The lock must precede the flip `.set()` that writes the auto-approved marker (and the cap read between them).
-        const flipCallIndex = setSpy.mock.calls.findIndex(([arg]) => arg?.reviewReason === 'auto-approved');
-        expect(flipCallIndex).toBeGreaterThanOrEqual(0);
-        const flipOrder = setSpy.mock.invocationCallOrder.at(flipCallIndex);
-        if (flipOrder === undefined) {
-            throw new Error('expected the flip call to have been recorded');
-        }
-        expect(lockOrder).toBeLessThan(flipOrder);
-    });
-    it('reverts the flip to pending when the audit write fails, instead of leaving it stuck processing', async () => {
-        const dz = makeDrizzle({
-            select: [
-                ...holdSelect().map((r) => [r]),
-                [], // resolveAutoThreshold -> global fallback
-                [{ n: 1 }], // velocity
-                [{ total: '0', n: 0 }], // caps
-                [
-                    {
-                        id: 'tx-1',
-                        walletId: 'w-1',
-                        type: 'withdrawal',
-                        status: 'pending',
-                        amount: '40',
-                        currency: 'USD',
-                    },
-                ], // flipToProcessing's FOR UPDATE select
-            ],
-            returning: [
-                ...holdReturning(),
-                [
-                    {
-                        id: 'tx-1',
-                        walletId: 'w-1',
-                        status: 'processing',
-                        amount: '40',
-                        currency: 'USD',
-                        rail: 'fiat',
-                    },
-                ], // flipToProcessing's update...returning
-            ],
-        });
-        const setSpy = readPrivate(dz.db, 'set');
-        const { svc, audit, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000' },
-        });
-        audit.record.mockRejectedValueOnce(new Error('audit down'));
+    it('reverts the flip to pending when the audit write fails instead of stranding it processing', async () => {
+        const { svc, audit, psp } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        audit.record.mockRejectedValueOnce(new Error('audit sink down'));
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
-        expect(result).toEqual({ transactionId: 'tx-1', status: 'pending' });
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
-        expect(setSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'processing', reviewReason: 'auto-approved' }));
-        expect(setSpy).toHaveBeenCalledWith(expect.objectContaining({
+        expect(result.status).toBe('pending');
+        expect(psp.processWithdrawal).not.toHaveBeenCalled();
+        expect(await txById(result.transactionId)).toMatchObject({
             status: 'pending',
             reviewedBy: null,
             reviewedAt: null,
             reviewReason: null,
-        }));
-    });
-    it('stays pending when KYC is not passing even though kyc.gateWithdrawals is false', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), []],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: {
-                lookupPlayers: vi.fn().mockResolvedValue([{ userId: 'u-1', kycStatus: 'pending' }]),
-            },
-            kyc: { gateWithdrawals: false },
-            autoWithdrawal: { fiatThreshold: '1000' },
         });
+    });
+    it('holds the funds even when auto-approval declines', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '10' } });
+        const w = await seedWallet({ balance: '100' });
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
+        const [row] = await db.drizzle.db.select().from(wallet).where(eq(wallet.id, w.id));
+        expect(Number(row?.balance)).toBe(60);
     });
-    it('stays pending when the player carries an excluded risk flag', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), []],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            riskTags: {
-                getActiveTagKeys: vi.fn().mockResolvedValue(new Map([['u-1', ['high_risk']]])),
-            },
-            autoWithdrawal: { fiatThreshold: '1000', excludeRiskFlags: ['high_risk'] },
+    it('stays pending when the amount exceeds the configured threshold', async () => {
+        const { svc, psp } = makeService({ autoWithdrawal: { fiatThreshold: '10' } });
+        const w = await seedWallet();
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
+            ...NO_CLIENT_META,
         });
+        expect(result.status).toBe('pending');
+        expect(psp.processWithdrawal).not.toHaveBeenCalled();
+    });
+    it('stays pending when no threshold is configured at all', async () => {
+        const { svc } = makeService({ autoWithdrawal: {} });
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
     });
-    it('stays pending on a high_frequency velocity flag', async () => {
-        const dz = makeDrizzle({
-            // grouped velocity count returns the wallet with >= 3 withdrawals in the window
-            select: [...holdSelect().map((r) => [r]), [], [{ walletId: 'w-1', n: 3 }]],
-            returning: [...holdReturning()],
+    it('stays pending when auto-withdrawal is not enabled', async () => {
+        const { svc, audit } = makeService();
+        const w = await seedWallet();
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
+            ...NO_CLIENT_META,
         });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
+        expect(result.status).toBe('pending');
+        expect(audit.record).not.toHaveBeenCalled();
+    });
+    it('stays pending when KYC is not passing even though gateWithdrawals is off', async () => {
+        const { svc } = makeService({
             autoWithdrawal: { fiatThreshold: '1000' },
+            kycStatus: 'pending',
         });
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
     });
-    it('stays pending when a configured daily count cap would be exceeded', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), [], [{ n: 1 }], [{ total: '0', n: 1 }]],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000', dailyCapCount: 1 },
+    it('fails closed to pending when the directory throws during the KYC check', async () => {
+        const { svc } = makeService({
+            autoWithdrawal: { fiatThreshold: '1000' },
+            directoryThrows: true,
         });
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
     });
-    it('stays pending when a configured daily amount cap would be exceeded', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), [], [{ n: 1 }], [{ total: '80', n: 1 }]],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000', dailyCapAmount: '100' },
+    it('stays pending when the player carries an excluded risk flag', async () => {
+        const { svc } = makeService({
+            autoWithdrawal: { fiatThreshold: '1000', excludeRiskFlags: ['bonus_abuser'] },
+            riskTags: ['bonus_abuser'],
         });
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
     });
-    it('fails closed to pending when risk flags are configured but PLAYER_TAGS is unbound', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), []],
-            returning: [...holdReturning()],
+    it('auto-approves when the player carries only unrelated tags', async () => {
+        const { svc } = makeService({
+            autoWithdrawal: { fiatThreshold: '1000', excludeRiskFlags: ['bonus_abuser'] },
+            riskTags: ['vip'],
         });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000', excludeRiskFlags: ['high_risk'] },
+        const w = await seedWallet();
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
+            ...NO_CLIENT_META,
+        });
+        expect(result.status).toBe('completed');
+    });
+    it('fails closed to pending when risk flags are configured but the tags port is unbound', async () => {
+        const { svc } = makeService({
+            autoWithdrawal: { fiatThreshold: '1000', excludeRiskFlags: ['bonus_abuser'] },
+            riskTags: 'unbound',
         });
+        const w = await seedWallet();
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
     });
-    it('fails closed to pending when the directory throws during the KYC check', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), []],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: { lookupPlayers: vi.fn().mockRejectedValue(new Error('directory down')) },
-            autoWithdrawal: { fiatThreshold: '1000' },
+    it('stays pending on the large_amount heuristic regardless of the threshold', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '100000' } });
+        const w = await seedWallet();
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '5000',
+            currency: 'USD',
+            ...NO_CLIENT_META,
         });
+        expect(result.status).toBe('pending');
+    });
+    it('stays pending once the wallet hits the high_frequency velocity flag', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        const w = await seedWallet();
+        await db.drizzle.db.insert(walletTransaction).values([
+            { walletId: w.id, type: 'withdrawal', amount: '1', currency: 'USD', status: 'completed' },
+            { walletId: w.id, type: 'withdrawal', amount: '1', currency: 'USD', status: 'completed' },
+        ]);
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
-    });
-    it('stays pending for crypto when no cryptoThreshold is configured (opt-in required, never silently active)', async () => {
-        const dz = makeDrizzle({
-            select: [[{ id: 'w-1', userId: 'u-1', balance: '100', currency: 'BTC' }], []],
-            returning: [
-                [{ id: 'tx-1', walletId: 'w-1', amount: '1', currency: 'BTC', status: 'pending' }],
-                [{ id: 'w-1' }],
-            ],
-        });
-        const directory = verifiedDirectory();
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory,
-            autoWithdrawal: { fiatThreshold: '1000000' },
+    });
+    it('ignores withdrawals outside the velocity window', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        const w = await seedWallet();
+        const outsideWindow = new Date(Date.now() - 48 * 60 * 60 * 1000);
+        await db.drizzle.db.insert(walletTransaction).values([
+            {
+                walletId: w.id,
+                type: 'withdrawal',
+                amount: '1',
+                currency: 'USD',
+                status: 'completed',
+                createdAt: outsideWindow,
+            },
+            {
+                walletId: w.id,
+                type: 'withdrawal',
+                amount: '1',
+                currency: 'USD',
+                status: 'completed',
+                createdAt: outsideWindow,
+            },
+        ]);
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
+            ...NO_CLIENT_META,
+        });
+        expect(result.status).toBe('completed');
+    });
+    it('stays pending when a configured daily count cap would be exceeded', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000', dailyCapCount: 1 } });
+        const w = await seedWallet();
+        await db.drizzle.db.insert(walletTransaction).values({
+            walletId: w.id,
+            type: 'withdrawal',
+            amount: '10',
+            currency: 'USD',
+            status: 'completed',
+            reviewReason: 'auto-approved',
         });
         const result = await svc.withdraw({
-            userId: 'u-1',
-            amount: '1',
-            currency: 'BTC',
-            destinationAddress: 'bc1qtest',
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
-        expect(directory.lookupPlayers).not.toHaveBeenCalled();
-    });
-    it('auto-approves a crypto withdrawal once an operator configures a positive cryptoThreshold', async () => {
-        const btcWallet = { id: 'w-1', userId: 'u-1', balance: '10', currency: 'BTC' };
-        const dz = makeDrizzle({
-            select: [
-                ...holdSelect(btcWallet).map((r) => [r]),
-                [],
-                [{ walletId: 'w-1', n: 1 }],
-                [{ total: '0', n: 0 }],
-                [
-                    {
-                        id: 'tx-1',
-                        walletId: 'w-1',
-                        type: 'withdrawal',
-                        status: 'pending',
-                        amount: '0.5',
-                        currency: 'BTC',
-                    },
-                ],
-                [{ userId: 'u-1' }],
-                [],
-            ],
-            returning: [
-                ...holdReturning(insertRow({ currency: 'BTC', rail: 'crypto', amount: '0.5' })),
-                [
-                    {
-                        id: 'tx-1',
-                        walletId: 'w-1',
-                        status: 'processing',
-                        amount: '0.5',
-                        currency: 'BTC',
-                        rail: 'crypto',
-                    },
-                ],
-            ],
-        });
-        const { svc, payment, audit } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { cryptoThreshold: '1' },
+    });
+    it('stays pending when a configured daily amount cap would be exceeded', async () => {
+        const { svc } = makeService({
+            autoWithdrawal: { fiatThreshold: '1000', dailyCapAmount: '50' },
+        });
+        const w = await seedWallet();
+        await db.drizzle.db.insert(walletTransaction).values({
+            walletId: w.id,
+            type: 'withdrawal',
+            amount: '20',
+            currency: 'USD',
+            status: 'completed',
+            reviewReason: 'auto-approved',
         });
         const result = await svc.withdraw({
-            userId: 'u-1',
-            amount: '0.5',
-            currency: 'BTC',
-            destinationAddress: 'bc1qtest',
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
             ...NO_CLIENT_META,
         });
-        expect(result).toEqual({ transactionId: 'tx-1', status: 'completed' });
-        expect(payment.processWithdrawal).toHaveBeenCalledTimes(1);
-        expect(audit.record).toHaveBeenCalledWith(expect.objectContaining({
-            after: expect.objectContaining({ threshold: '1', thresholdSource: 'global' }),
-        }));
+        expect(result.status).toBe('pending');
     });
-    it('stays pending when the crypto amount exceeds the configured cryptoThreshold', async () => {
-        const btcWallet = { id: 'w-1', userId: 'u-1', balance: '10', currency: 'BTC' };
-        const dz = makeDrizzle({
-            select: [...holdSelect(btcWallet).map((r) => [r]), []],
-            returning: [...holdReturning(insertRow({ currency: 'BTC', rail: 'crypto', amount: '5' }))],
+    it('counts only auto-approved payouts towards the daily cap', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000', dailyCapCount: 1 } });
+        const w = await seedWallet();
+        await db.drizzle.db.insert(walletTransaction).values({
+            walletId: w.id,
+            type: 'withdrawal',
+            amount: '10',
+            currency: 'USD',
+            status: 'completed',
+            reviewReason: 'manual sign-off',
         });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { cryptoThreshold: '1' },
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
+            ...NO_CLIENT_META,
         });
+        expect(result.status).toBe('completed');
+    });
+    it('serializes concurrent withdrawals so a count cap of one cannot be bypassed', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000', dailyCapCount: 1 } });
+        const w = await seedWallet();
+        const results = await Promise.all([
+            svc.withdraw({ userId: w.userId, amount: '40', currency: 'USD', ...NO_CLIENT_META }),
+            svc.withdraw({ userId: w.userId, amount: '41', currency: 'USD', ...NO_CLIENT_META }),
+        ]);
+        expect(results.filter((r) => r.status === 'completed')).toHaveLength(1);
+        expect(results.filter((r) => r.status === 'pending')).toHaveLength(1);
+    });
+});
+describe('WalletService.withdraw auto-approval - crypto rail (real PG)', () => {
+    it('stays pending when no cryptoThreshold is configured, even with a fiat one', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        const w = await seedWallet({ currency: 'BTC', balance: '10' });
         const result = await svc.withdraw({
-            userId: 'u-1',
-            amount: '5',
+            userId: w.userId,
+            amount: '1',
             currency: 'BTC',
-            destinationAddress: 'bc1qtest',
+            destinationAddress: 'bc1qexample',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
-    });
-    it('stays pending for a crypto withdrawal below cryptoThreshold when KYC is not passing (same guard as fiat)', async () => {
-        const btcWallet = { id: 'w-1', userId: 'u-1', balance: '10', currency: 'BTC' };
-        const dz = makeDrizzle({
-            select: [...holdSelect(btcWallet).map((r) => [r]), []],
-            returning: [...holdReturning(insertRow({ currency: 'BTC', rail: 'crypto', amount: '0.5' }))],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: {
-                lookupPlayers: vi.fn().mockResolvedValue([{ userId: 'u-1', kycStatus: 'pending' }]),
-            },
-            autoWithdrawal: { cryptoThreshold: '1' },
+    });
+    it('auto-approves once an operator configures a positive cryptoThreshold', async () => {
+        const { svc } = makeService({ autoWithdrawal: { cryptoThreshold: '2' } });
+        const w = await seedWallet({ currency: 'BTC', balance: '10' });
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '1',
+            currency: 'BTC',
+            destinationAddress: 'bc1qexample',
+            ...NO_CLIENT_META,
+        });
+        expect(result.status).toBe('completed');
+        expect(await txById(result.transactionId)).toMatchObject({
+            rail: 'crypto',
+            providerName: 'fireblocks',
+            reviewReason: 'auto-approved',
         });
+    });
+    it('stays pending when the crypto amount exceeds cryptoThreshold', async () => {
+        const { svc } = makeService({ autoWithdrawal: { cryptoThreshold: '0.5' } });
+        const w = await seedWallet({ currency: 'BTC', balance: '10' });
         const result = await svc.withdraw({
-            userId: 'u-1',
-            amount: '0.5',
+            userId: w.userId,
+            amount: '1',
             currency: 'BTC',
-            destinationAddress: 'bc1qtest',
+            destinationAddress: 'bc1qexample',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
     });
-    it('stays pending when no threshold is configured (no per-player rule, no global)', async () => {
-        const dz = makeDrizzle({
-            select: [...holdSelect().map((r) => [r]), []],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: {}, // enabled, but no fiatThreshold
+    it('applies the same KYC guard as the fiat rail', async () => {
+        const { svc } = makeService({
+            autoWithdrawal: { cryptoThreshold: '2' },
+            kycStatus: 'rejected',
         });
+        const w = await seedWallet({ currency: 'BTC', balance: '10' });
         const result = await svc.withdraw({
-            userId: 'u-1',
-            amount: '40',
-            currency: 'USD',
+            userId: w.userId,
+            amount: '1',
+            currency: 'BTC',
+            destinationAddress: 'bc1qexample',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
-    });
-    it('per-player rule below the global threshold blocks what global would allow', async () => {
-        const dz = makeDrizzle({
-            select: [
-                ...holdSelect().map((r) => [r]),
-                [{ id: 'r-1', userId: 'u-1', threshold: '10', reason: 'watch', createdBy: 'a-1' }],
-            ],
-            returning: [...holdReturning()],
-        });
-        const { svc, payment } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '1000' },
+    });
+});
+describe('WalletService auto-approval threshold resolution (real PG)', () => {
+    it('a per-player rule below the global threshold blocks what global would allow', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        const w = await seedWallet();
+        await svc.setAutoWithdrawalRule({
+            userId: w.userId,
+            threshold: '10',
+            reason: 'watchlist',
+            createdBy: randomUUID(),
         });
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('pending');
-        expect(payment.processWithdrawal).not.toHaveBeenCalled();
-    });
-    it('per-player rule above the global threshold allows what global would block', async () => {
-        const dz = makeDrizzle({
-            select: [
-                ...holdSelect().map((r) => [r]),
-                [{ id: 'r-1', userId: 'u-1', threshold: '1000', reason: 'trusted', createdBy: 'a-1' }],
-                [{ n: 1 }],
-                [{ total: '0', n: 0 }],
-                ...finalizeSelect(),
-            ],
-            returning: [...holdReturning(), ...finalizeReturning()],
-        });
-        const { svc, payment, audit } = makeSvc({
-            drizzle: dz,
-            directory: verifiedDirectory(),
-            autoWithdrawal: { fiatThreshold: '10' },
+    });
+    it('a per-player rule above the global threshold allows what global would block', async () => {
+        const { svc, audit } = makeService({ autoWithdrawal: { fiatThreshold: '10' } });
+        const w = await seedWallet();
+        await svc.setAutoWithdrawalRule({
+            userId: w.userId,
+            threshold: '1000',
+            reason: 'trusted',
+            createdBy: randomUUID(),
         });
         const result = await svc.withdraw({
-            userId: 'u-1',
+            userId: w.userId,
             amount: '40',
             currency: 'USD',
             ...NO_CLIENT_META,
         });
         expect(result.status).toBe('completed');
-        expect(payment.processWithdrawal).toHaveBeenCalledTimes(1);
         expect(audit.record).toHaveBeenCalledWith(expect.objectContaining({
-            after: expect.objectContaining({ threshold: '1000', thresholdSource: 'per-player' }),
+            after: expect.objectContaining({ thresholdSource: 'per-player' }),
         }));
     });
-});
-describe('WalletService auto-withdrawal rule methods', () => {
-    beforeEach(() => vi.clearAllMocks());
-    it('setAutoWithdrawalRule upserts and returns the rule with a decimal threshold', async () => {
-        const dz = makeDrizzle({
-            returning: [
-                [
-                    {
-                        id: 'r-1',
-                        userId: 'u-1',
-                        threshold: '500',
-                        reason: 'trusted',
-                        createdBy: 'a-1',
-                        createdAt: new Date('2026-01-01T00:00:00Z'),
-                        updatedAt: new Date('2026-01-01T00:00:00Z'),
-                    },
-                ],
-            ],
-        });
-        const { svc } = makeSvc({ drizzle: dz });
-        const rule = await svc.setAutoWithdrawalRule({
-            userId: 'u-1',
-            threshold: '500',
+    it('a per-player rule overrides the crypto threshold too', async () => {
+        const { svc } = makeService({ autoWithdrawal: { cryptoThreshold: '0.5' } });
+        const w = await seedWallet({ currency: 'BTC', balance: '10' });
+        await svc.setAutoWithdrawalRule({
+            userId: w.userId,
+            threshold: '5',
             reason: 'trusted',
-            createdBy: 'a-1',
+            createdBy: randomUUID(),
         });
-        expect(rule).toMatchObject({
-            id: 'r-1',
-            userId: 'u-1',
-            threshold: '500',
-            reason: 'trusted',
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '1',
+            currency: 'BTC',
+            destinationAddress: 'bc1qexample',
+            ...NO_CLIENT_META,
+        });
+        expect(result.status).toBe('completed');
+    });
+    it('a zero per-player threshold turns auto-approval off for that player', async () => {
+        const { svc } = makeService({ autoWithdrawal: { fiatThreshold: '1000' } });
+        const w = await seedWallet();
+        await svc.setAutoWithdrawalRule({
+            userId: w.userId,
+            threshold: '0',
+            reason: 'manual only',
+            createdBy: randomUUID(),
+        });
+        const result = await svc.withdraw({
+            userId: w.userId,
+            amount: '40',
+            currency: 'USD',
+            ...NO_CLIENT_META,
         });
-        expect(typeof rule.createdAt).toBe('string');
+        expect(result.status).toBe('pending');
+    });
+});
+describe('WalletService auto-withdrawal rule methods (real PG)', () => {
+    it('setAutoWithdrawalRule inserts, then upserts on a repeat for the same player', async () => {
+        const { svc } = makeService();
+        const userId = randomUUID();
+        const createdBy = randomUUID();
+        const created = await svc.setAutoWithdrawalRule({
+            userId,
+            threshold: '500',
+            reason: 'initial',
+            createdBy,
+        });
+        const updated = await svc.setAutoWithdrawalRule({
+            userId,
+            threshold: '750',
+            reason: 'raised',
+            createdBy,
+        });
+        expect(created.id).toBe(updated.id);
+        expect(Number(updated.threshold)).toBe(750);
+        expect(updated.reason).toBe('raised');
+        const rows = await db.drizzle.db
+            .select()
+            .from(autoWithdrawalRule)
+            .where(eq(autoWithdrawalRule.userId, userId));
+        expect(rows).toHaveLength(1);
     });
     it('getAutoWithdrawalRule returns null when no rule exists', async () => {
-        const dz = makeDrizzle({ select: [[]] });
-        const { svc } = makeSvc({ drizzle: dz });
-        expect(await svc.getAutoWithdrawalRule('u-1')).toBeNull();
+        const { svc } = makeService();
+        expect(await svc.getAutoWithdrawalRule(randomUUID())).toBeNull();
+    });
+    it('getAutoWithdrawalRule serializes the timestamps as ISO strings', async () => {
+        const { svc } = makeService();
+        const userId = randomUUID();
+        await svc.setAutoWithdrawalRule({
+            userId,
+            threshold: '500',
+            reason: 'initial',
+            createdBy: randomUUID(),
+        });
+        const rule = await svc.getAutoWithdrawalRule(userId);
+        expect(rule?.createdAt).toBe(new Date(rule?.createdAt ?? '').toISOString());
     });
     it('deleteAutoWithdrawalRule reports whether a row was removed', async () => {
-        const dz = makeDrizzle({ returning: [[{ id: 'r-1' }]] });
-        const { svc } = makeSvc({ drizzle: dz });
-        expect(await svc.deleteAutoWithdrawalRule('u-1')).toBe(true);
-        const empty = makeDrizzle({ returning: [[]] });
-        const { svc: svc2 } = makeSvc({ drizzle: empty });
-        expect(await svc2.deleteAutoWithdrawalRule('u-1')).toBe(false);
+        const { svc } = makeService();
+        const userId = randomUUID();
+        await svc.setAutoWithdrawalRule({
+            userId,
+            threshold: '500',
+            reason: 'initial',
+            createdBy: randomUUID(),
+        });
+        expect(await svc.deleteAutoWithdrawalRule(userId)).toBe(true);
+        expect(await svc.deleteAutoWithdrawalRule(userId)).toBe(false);
+        expect(await svc.getAutoWithdrawalRule(userId)).toBeNull();
     });
 });
 //# sourceMappingURL=wallet-auto-withdrawal.test.js.map