@openora/core 0.4.0 → 0.4.1-canary.11

package/dist/wallet/service/wallet.service.js

@@ -1,4 +1,4 @@
-import { makeNotFoundError, makeConflictError, createDomainError, findOneOrThrow, pageToOffset, withAdvisoryXactLock, assertRateLimit, createLogger, } from '@openora/core/server';
+import { makeNotFoundError, makeConflictError, createDomainError, findOneOrThrow, pageToOffset, withAdvisoryXactLock, assertRateLimit, createLogger, moneyToNumber, } from '@openora/core/server';
 import { eq, desc, sql, and, gte, lte, count, inArray } from 'drizzle-orm';
 import { createHash } from 'node:crypto';
 import { wallet, walletTransaction, autoWithdrawalRule, } from '../schema/index.js';
@@ -39,7 +39,8 @@ function namespacedIdempotencyKey(namespace, rawKey) {
 }
 // ponytail: a flat, currency-agnostic threshold - a starter heuristic for the review
 // queue, not a compliance risk engine. Revisit with a real risk service if/when one exists.
-const LARGE_WITHDRAWAL_THRESHOLD = 5000;
+// moneyToNumber is the sanctioned JS conversion point for this heuristic comparison only.
+const LARGE_WITHDRAWAL_THRESHOLD = '5000';
 // ponytail: >=3 withdrawals in a 24h window flags velocity; a flat count, not a per-tier rule.
 const HIGH_FREQUENCY_WINDOW_MS = 24 * 60 * 60 * 1000;
 const HIGH_FREQUENCY_MIN_COUNT = 3;
@@ -50,7 +51,7 @@ function toAutoWithdrawalRuleDto(row) {
     return {
         id: row.id,
         userId: row.userId,
-        threshold: Number(row.threshold),
+        threshold: row.threshold,
         reason: row.reason,
         createdBy: row.createdBy,
         createdAt: row.createdAt.toISOString(),
@@ -62,6 +63,14 @@ function toAutoWithdrawalRuleDto(row) {
 function providerNameFor(rail) {
     return rail === 'crypto' ? 'fireblocks' : 'psp';
 }
+/**
+ * Owns all wallet balance mutations and the withdrawal review/auto-approval
+ * pipeline. Every balance change is a transactional, idempotent-keyed ledger
+ * write (never a bare balance update) - `amount` is always a decimal string,
+ * mutated via SQL numeric arithmetic, never a JS float. Domain events emit only
+ * AFTER the owning transaction commits, and only for the non-replay branch of
+ * an idempotent call.
+ */
 export class WalletService {
     drizzle;
     events;
@@ -88,8 +97,9 @@ export class WalletService {
     }
     /** Fail-closed KYC gate: when enabled, a withdrawal needs a passing status (verified|manually_overridden). */
     async assertKycForWithdrawal(userId) {
-        if (!this.platformConfig?.kyc?.gateWithdrawals)
+        if (!this.platformConfig?.kyc?.gateWithdrawals) {
             return;
+        }
         const status = await this.autoApprovalKycStatus(userId);
         if (!status || !KYC_PASS_STATUSES.has(status)) {
             throw new KycRequiredError();
@@ -98,13 +108,23 @@ export class WalletService {
     async getBalance(userId) {
         const [record] = await this.drizzle.db.select().from(wallet).where(eq(wallet.userId, userId));
         if (!record) {
-            return { balance: 0, currency: 'USD' };
+            return { balance: '0', currency: 'USD' };
         }
         return {
-            balance: Number(record.balance),
+            balance: record.balance,
             currency: record.currency,
         };
     }
+    /**
+     * `idempotencyKey` (when supplied) makes a retried deposit a no-op: a replay
+     * returns the original committed result WITHOUT calling the PSP again or
+     * crediting the balance twice, and rejects if the same key is reused with a
+     * different amount/currency (`IdempotencyKeyReuseError`). A GENUINE
+     * concurrent race (two first-attempts, same key, landing at once) can both
+     * reach the PSP, but the ledger insert's unique-index conflict still
+     * guarantees only one balance credit - the loser's write becomes a replay
+     * read of the winner's row.
+     */
     async deposit({ userId, amount, currency, provider, idempotencyKey, }) {
         await this.rateLimit(userId);
         // Short-circuit a replay BEFORE the PSP call - the common retry case (client
@@ -114,8 +134,9 @@ export class WalletService {
         let preResolvedWallet;
         if (idempotencyKey) {
             const found = await this.findDepositReplay({ userId, idempotencyKey, amount, currency });
-            if (found.replay)
+            if (found.replay) {
                 return found.replay;
+            }
             preResolvedWallet = found.walletRecord;
         }
         const psp = await this.payment.processDeposit(amount, currency, { userId, provider });
@@ -125,10 +146,7 @@ export class WalletService {
                 [walletRecord] = await txn.select().from(wallet).where(eq(wallet.userId, userId));
             }
             if (!walletRecord) {
-                [walletRecord] = await txn
-                    .insert(wallet)
-                    .values({ userId, balance: '0', currency })
-                    .returning();
+                walletRecord = findOneOrThrow(await txn.insert(wallet).values({ userId, balance: '0', currency }).returning(), new WalletNotFoundError(userId));
             }
             const { row, replayed } = await this.insertIdempotentTransaction(txn, {
                 namespace: DEPOSIT_IDEMPOTENCY_NAMESPACE,
@@ -139,7 +157,7 @@ export class WalletService {
                 values: {
                     walletId: walletRecord.id,
                     type: 'deposit',
-                    amount: amount.toString(),
+                    amount,
                     currency,
                     status: 'completed',
                     rail: railFor(currency),
@@ -150,13 +168,18 @@ export class WalletService {
             if (!replayed) {
                 await txn
                     .update(wallet)
-                    .set({ balance: sql `${wallet.balance} + ${amount}` })
+                    .set({ balance: sql `${wallet.balance} + ${amount}::numeric` })
                     .where(eq(wallet.id, walletRecord.id));
             }
             return { transactionId: row.id, replayed };
         });
         if (!replayed) {
-            this.events.emit('wallet.deposit.completed', { userId, amount, currency, transactionId });
+            this.events.emit('wallet.deposit.completed', {
+                userId,
+                amount,
+                currency,
+                transactionId,
+            });
         }
         return { transactionId, status: 'completed' };
     }
@@ -167,16 +190,20 @@ export class WalletService {
             .select()
             .from(wallet)
             .where(eq(wallet.userId, userId));
-        if (!walletRecord)
+        if (!walletRecord) {
             return { walletRecord: undefined, replay: undefined };
+        }
         const existing = await this.findByIdempotencyKey(this.drizzle.db, walletRecord.id, namespacedIdempotencyKey(DEPOSIT_IDEMPOTENCY_NAMESPACE, idempotencyKey));
-        if (!existing)
+        if (!existing) {
             return { walletRecord, replay: undefined };
+        }
         this.assertReplayMatches(existing, amount, currency);
         return { walletRecord, replay: { transactionId: existing.id, status: existing.status } };
     }
+    // Replay comparison only (not a ledger write) - moneyToNumber avoids a false mismatch
+    // between an unnormalized caller string (eg "10") and the DB's fixed-scale value ("10.00").
     assertReplayMatches(existing, amount, currency) {
-        if (Number(existing.amount) !== amount ||
+        if (moneyToNumber(existing.amount) !== moneyToNumber(amount) ||
             existing.currency.toUpperCase() !== currency.toUpperCase()) {
             throw new IdempotencyKeyReuseError();
         }
@@ -194,8 +221,9 @@ export class WalletService {
         const [row] = idempotencyKey
             ? await insertQuery.onConflictDoNothing().returning()
             : await insertQuery.returning();
-        if (row)
+        if (row) {
             return { row, replayed: false };
+        }
         // Only the keyed (onConflictDoNothing) branch above can return an empty `returning()`
         // - the plain-insert branch always yields exactly one row.
         if (!idempotencyKey) {
@@ -208,7 +236,16 @@ export class WalletService {
         this.assertReplayMatches(winner, amount, currency);
         return { row: winner, replayed: true };
     }
-    /** Creates a PENDING withdrawal and HOLDS the funds (balance debited at request time). Funds are returned on reject/PSP-failure. */
+    /**
+     * Creates a PENDING withdrawal and HOLDS the funds immediately (balance
+     * debited at request time, not on approval) - funds are returned on
+     * reject/PSP-failure. The debit is a conditional `UPDATE ... WHERE balance
+     * >= amount`, atomic with the row lock (`FOR UPDATE`) taken on the wallet,
+     * so two concurrent withdrawals can't both pass a balance check and
+     * double-spend. `idempotencyKey` replay semantics mirror `deposit()`. May
+     * return an already-`completed`/`processing` result if the request
+     * qualifies for (and passes) auto-approval - see `maybeAutoApprove`.
+     */
     async withdraw({ userId, amount, currency, idempotencyKey, }) {
         await this.rateLimit(userId);
         await this.assertKycForWithdrawal(userId);
@@ -242,7 +279,7 @@ export class WalletService {
                 values: {
                     walletId: current.id,
                     type: 'withdrawal',
-                    amount: amount.toString(),
+                    amount,
                     currency,
                     status: 'pending',
                     rail: railFor(currency),
@@ -260,11 +297,11 @@ export class WalletService {
             // Guarded conditional debit: the WHERE makes balance>=amount atomic with the write; 0 rows back rolls back the whole tx.
             const debited = await txn
                 .update(wallet)
-                .set({ balance: sql `${wallet.balance} - ${amount}` })
-                .where(and(eq(wallet.id, current.id), gte(wallet.balance, amount.toString())))
+                .set({ balance: sql `${wallet.balance} - ${amount}::numeric` })
+                .where(and(eq(wallet.id, current.id), gte(wallet.balance, amount)))
                 .returning({ id: wallet.id });
             if (debited.length !== 1) {
-                throw new InsufficientBalanceError(Number(current.balance), amount);
+                throw new InsufficientBalanceError(current.balance, amount);
             }
             return {
                 transactionId: row.id,
@@ -274,9 +311,15 @@ export class WalletService {
                 rail: railFor(currency),
             };
         });
-        if (replayed)
+        if (replayed) {
             return { transactionId, status };
-        this.events.emit('wallet.withdrawal.requested', { userId, amount, currency, transactionId });
+        }
+        this.events.emit('wallet.withdrawal.requested', {
+            userId,
+            amount,
+            currency,
+            transactionId,
+        });
         // Fail-closed post-step: decides who approves (system vs manual queue), never throws out of withdraw() - failure leaves the row pending.
         const auto = await this.maybeAutoApprove({
             userId,
@@ -292,17 +335,20 @@ export class WalletService {
         const db = this.drizzle.db;
         const { page, limit } = filters;
         const conditions = [eq(walletTransaction.type, 'withdrawal')];
-        if (filters.status)
+        if (filters.status) {
             conditions.push(eq(walletTransaction.status, filters.status));
-        if (filters.currency)
+        }
+        if (filters.currency) {
             conditions.push(eq(walletTransaction.currency, filters.currency));
-        if (filters.rail)
+        }
+        if (filters.rail) {
             conditions.push(eq(walletTransaction.rail, filters.rail));
+        }
         if (filters.minAmount !== undefined) {
-            conditions.push(gte(walletTransaction.amount, filters.minAmount.toString()));
+            conditions.push(gte(walletTransaction.amount, filters.minAmount));
         }
         if (filters.maxAmount !== undefined) {
-            conditions.push(lte(walletTransaction.amount, filters.maxAmount.toString()));
+            conditions.push(lte(walletTransaction.amount, filters.maxAmount));
         }
         if (filters.dateFrom) {
             conditions.push(gte(walletTransaction.createdAt, new Date(filters.dateFrom)));
@@ -324,7 +370,7 @@ export class WalletService {
         const matching = filters.kycStatus
             ? rows.filter((r) => byUserId.get(r.userId)?.kycStatus === filters.kycStatus)
             : rows;
-        const start = (page - 1) * limit;
+        const start = pageToOffset(page, limit);
         const pageRows = matching.slice(start, start + limit);
         // One batched velocity query for the page (no N+1); shares the window + threshold + query the auto-approval evaluator uses.
         const pageWalletIds = [...new Set(pageRows.map((r) => r.tx.walletId))];
@@ -332,15 +378,17 @@ export class WalletService {
         const items = pageRows.map((r) => {
             const summary = byUserId.get(r.userId);
             const riskTags = [];
-            if (Number(r.tx.amount) >= LARGE_WITHDRAWAL_THRESHOLD)
+            if (moneyToNumber(r.tx.amount) >= moneyToNumber(LARGE_WITHDRAWAL_THRESHOLD)) {
                 riskTags.push('large_amount');
-            if (frequentWalletIds.has(r.tx.walletId))
+            }
+            if (frequentWalletIds.has(r.tx.walletId)) {
                 riskTags.push('high_frequency');
+            }
             return {
                 transactionId: r.tx.id,
                 userId: r.userId,
                 username: summary?.username ?? '',
-                amount: Number(r.tx.amount),
+                amount: r.tx.amount,
                 currency: r.tx.currency,
                 rail: r.tx.rail ?? null,
                 status: r.tx.status,
@@ -374,7 +422,7 @@ export class WalletService {
         if (current.status !== 'pending' || current.type !== 'withdrawal') {
             throw new WithdrawalNotPendingError();
         }
-        const [updated] = await txn
+        return findOneOrThrow(await txn
             .update(walletTransaction)
             .set({
             status: 'processing',
@@ -383,14 +431,13 @@ export class WalletService {
             ...(reviewReason !== undefined ? { reviewReason } : {}),
         })
             .where(eq(walletTransaction.id, withdrawalId))
-            .returning();
-        return updated;
+            .returning(), new WithdrawalNotFoundError(withdrawalId));
     }
     // Phase two: settle a `processing` withdrawal via the PSP (Completed on success, Failed + refund on error).
     // Runs OUTSIDE the hold/flip transaction so the external PSP call never holds a DB lock.
     async settleApproved(tx, adminId) {
         const userId = await this.userIdForWallet(tx.walletId);
-        const amount = Number(tx.amount);
+        const amount = tx.amount;
         // approved/failed are admin-attributed events (schema requires a uuid adminId); the system auto path
         // skips them - its trail is the AUDIT_WRITER entry plus the shared `completed` event below.
         if (adminId) {
@@ -420,7 +467,7 @@ export class WalletService {
                     .where(eq(walletTransaction.id, tx.id));
                 await txn
                     .update(wallet)
-                    .set({ balance: sql `${wallet.balance} + ${amount}` })
+                    .set({ balance: sql `${wallet.balance} + ${amount}::numeric` })
                     .where(eq(wallet.id, tx.walletId));
             });
             if (adminId) {
@@ -454,22 +501,25 @@ export class WalletService {
     // leave the row pending for the manual queue. NEVER throws: any error fails closed to manual.
     async maybeAutoApprove(args) {
         // Cheap gates first (auto-approval off, or crypto - never auto-approved): skip opening a tx/lock.
-        if (!this.platformConfig?.autoWithdrawal?.enabled || args.rail !== 'fiat')
+        if (!this.platformConfig?.autoWithdrawal?.enabled || args.rail !== 'fiat') {
             return undefined;
+        }
         try {
             const cfg = this.platformConfig.autoWithdrawal;
             // Threshold/KYC/risk/velocity gates run outside any lock; only the cap check below needs serializing.
             const gates = await this.evaluateAutoApproval(args);
-            if (!gates)
+            if (!gates) {
                 return undefined;
+            }
             // Serialize the cap-check-and-flip per user with an advisory lock: without it two concurrent
             // withdrawals read the same daily-cap usage and both auto-approve, bypassing the cap. The cap read
             // and the flip that writes the marker commit together, so a blocked caller re-reads current usage.
             // PSP settlement runs AFTER, outside the lock.
             const decided = await this.drizzle.db.transaction((txn) => withAdvisoryXactLock(txn, args.userId, async () => {
                 const caps = await this.autoApprovalCaps({ walletId: args.walletId, amount: args.amount, cfg }, txn);
-                if (caps.exceeded)
+                if (caps.exceeded) {
                     return null;
+                }
                 const tx = await this.flipToProcessing({
                     txn,
                     withdrawalId: args.transactionId,
@@ -478,8 +528,9 @@ export class WalletService {
                 });
                 return { tx, caps };
             }));
-            if (!decided)
+            if (!decided) {
                 return undefined;
+            }
             const decision = {
                 ...gates,
                 dailyCapAmount: cfg.dailyCapAmount ?? null,
@@ -494,7 +545,12 @@ export class WalletService {
                     action: 'wallet.withdrawal.auto_approved',
                     resourceType: 'wallet_transaction',
                     resourceId: args.transactionId,
-                    after: { userId: args.userId, amount: args.amount, currency: args.currency, ...decision },
+                    after: {
+                        userId: args.userId,
+                        amount: args.amount,
+                        currency: args.currency,
+                        ...decision,
+                    },
                 });
             }
             catch (err) {
@@ -518,29 +574,37 @@ export class WalletService {
     // route to manual. The daily-cap check is NOT here - it runs under the advisory lock (see maybeAutoApprove).
     async evaluateAutoApproval({ userId, amount, walletId, rail, }) {
         const cfg = this.platformConfig?.autoWithdrawal;
-        if (!cfg?.enabled)
+        if (!cfg?.enabled) {
             return null;
+        }
         // Hard stop: crypto is irreversible and AML-sensitive - never auto-approved.
-        if (rail !== 'fiat')
+        if (rail !== 'fiat') {
             return null;
+        }
         const threshold = await this.resolveAutoThreshold(userId);
-        if (!threshold || threshold.value <= 0)
+        if (!threshold || moneyToNumber(threshold.value) <= 0) {
             return null;
-        if (amount > threshold.value)
+        }
+        if (moneyToNumber(amount) > moneyToNumber(threshold.value)) {
             return null;
+        }
         // Independent of kyc.gateWithdrawals: auto-approval always demands a passing status; anything else fails closed.
         const kycStatus = await this.autoApprovalKycStatus(userId);
-        if (!kycStatus || !KYC_PASS_STATUSES.has(kycStatus))
+        if (!kycStatus || !KYC_PASS_STATUSES.has(kycStatus)) {
             return null;
+        }
         const riskTags = await this.autoApprovalRiskTags(userId, cfg.excludeRiskFlags);
         // null = exclusions configured but the lookup port is unavailable => fail closed.
-        if (riskTags === null)
+        if (riskTags === null) {
             return null;
-        if (riskTags.some((t) => cfg.excludeRiskFlags.includes(t)))
+        }
+        if (riskTags.some((t) => cfg.excludeRiskFlags.includes(t))) {
             return null;
+        }
         const heuristics = await this.autoApprovalHeuristics({ walletId, amount });
-        if (heuristics.largeAmount || heuristics.highFrequency)
+        if (heuristics.largeAmount || heuristics.highFrequency) {
             return null;
+        }
         return {
             threshold: threshold.value,
             thresholdSource: threshold.source,
@@ -554,33 +618,38 @@ export class WalletService {
             .select()
             .from(autoWithdrawalRule)
             .where(eq(autoWithdrawalRule.userId, userId));
-        if (rule)
-            return { value: Number(rule.threshold), source: 'per-player' };
+        if (rule) {
+            return { value: rule.threshold, source: 'per-player' };
+        }
         const global = this.platformConfig?.autoWithdrawal?.fiatThreshold;
-        if (global !== undefined)
+        if (global !== undefined) {
             return { value: global, source: 'global' };
+        }
         return null;
     }
     async autoApprovalKycStatus(userId) {
         // No directory bound => cannot verify KYC => fail closed.
-        if (!this.directory)
+        if (!this.directory) {
             return null;
+        }
         const [summary] = await this.directory.lookupPlayers([userId]);
         return summary?.kycStatus ?? null;
     }
     // Active tag keys; [] when no exclusions configured or none carried; null when configured but the port is unbound (fail closed).
     async autoApprovalRiskTags(userId, excludeRiskFlags) {
-        if (excludeRiskFlags.length === 0)
+        if (excludeRiskFlags.length === 0) {
             return [];
-        if (!this.riskTags)
+        }
+        if (!this.riskTags) {
             return null;
+        }
         const byUser = await this.riskTags.getActiveTagKeys([userId]);
         return byUser.get(userId) ?? [];
     }
     async autoApprovalHeuristics({ walletId, amount, }) {
         const frequent = await this.frequentWithdrawalWalletIds(this.drizzle.db, [walletId]);
         return {
-            largeAmount: amount >= LARGE_WITHDRAWAL_THRESHOLD,
+            largeAmount: moneyToNumber(amount) >= moneyToNumber(LARGE_WITHDRAWAL_THRESHOLD),
             highFrequency: frequent.has(walletId),
         };
     }
@@ -588,8 +657,9 @@ export class WalletService {
     // Single source of the velocity check, shared by the review queue tag and the auto-approval heuristic.
     async frequentWithdrawalWalletIds(db, walletIds) {
         const frequent = new Set();
-        if (walletIds.length === 0)
+        if (walletIds.length === 0) {
             return frequent;
+        }
         const since = new Date(Date.now() - HIGH_FREQUENCY_WINDOW_MS);
         const counts = await db
             .select({ walletId: walletTransaction.walletId, n: count() })
@@ -597,8 +667,9 @@ export class WalletService {
             .where(and(eq(walletTransaction.type, 'withdrawal'), gte(walletTransaction.createdAt, since), inArray(walletTransaction.walletId, walletIds)))
             .groupBy(walletTransaction.walletId);
         for (const row of counts) {
-            if (Number(row.n) >= HIGH_FREQUENCY_MIN_COUNT)
+            if (Number(row.n) >= HIGH_FREQUENCY_MIN_COUNT) {
                 frequent.add(row.walletId);
+            }
         }
         return frequent;
     }
@@ -607,24 +678,30 @@ export class WalletService {
     async autoApprovalCaps({ walletId, amount, cfg, }, db) {
         const since = new Date(Date.now() - DAILY_CAP_WINDOW_MS);
         const [row] = await db
-            .select({ total: sql `coalesce(sum(${walletTransaction.amount}), 0)`, n: count() })
+            .select({
+            total: sql `coalesce(sum(${walletTransaction.amount}), 0)`,
+            n: count(),
+        })
             .from(walletTransaction)
             .where(and(eq(walletTransaction.walletId, walletId), eq(walletTransaction.type, 'withdrawal'), eq(walletTransaction.reviewReason, AUTO_APPROVED_REASON), gte(walletTransaction.createdAt, since)));
-        const amountUsed = Number(row?.total ?? 0);
+        const amountUsed = row?.total ?? '0';
         const countUsed = Number(row?.n ?? 0);
-        const amountExceeded = cfg.dailyCapAmount !== undefined && amountUsed + amount > cfg.dailyCapAmount;
+        // Cap comparison is a review-queue decision, not a ledger write - moneyToNumber is the
+        // documented single conversion point (see the helper's own doc comment).
+        const amountExceeded = cfg.dailyCapAmount !== undefined &&
+            moneyToNumber(amountUsed) + moneyToNumber(amount) > moneyToNumber(cfg.dailyCapAmount);
         const countExceeded = cfg.dailyCapCount !== undefined && countUsed + 1 > cfg.dailyCapCount;
         return { exceeded: amountExceeded || countExceeded, amountUsed, countUsed };
     }
     async setAutoWithdrawalRule({ userId, threshold, reason, createdBy, }) {
-        const [row] = await this.drizzle.db
+        const row = findOneOrThrow(await this.drizzle.db
             .insert(autoWithdrawalRule)
-            .values({ userId, threshold: threshold.toString(), reason, createdBy })
+            .values({ userId, threshold, reason, createdBy })
             .onConflictDoUpdate({
             target: autoWithdrawalRule.userId,
-            set: { threshold: threshold.toString(), reason, createdBy },
+            set: { threshold, reason, createdBy },
         })
-            .returning();
+            .returning(), new WalletNotFoundError(userId));
         return toAutoWithdrawalRuleDto(row);
     }
     async getAutoWithdrawalRule(userId) {
@@ -652,21 +729,21 @@ export class WalletService {
             if (current.status !== 'pending' || current.type !== 'withdrawal') {
                 throw new WithdrawalNotPendingError();
             }
-            const [updated] = await txn
+            const updated = findOneOrThrow(await txn
                 .update(walletTransaction)
                 .set({ status: 'rejected', reviewedBy: adminId, reviewedAt, reviewReason: reason })
                 .where(eq(walletTransaction.id, withdrawalId))
-                .returning();
+                .returning(), new WithdrawalNotFoundError(withdrawalId));
             await txn
                 .update(wallet)
-                .set({ balance: sql `${wallet.balance} + ${updated.amount}` })
+                .set({ balance: sql `${wallet.balance} + ${updated.amount}::numeric` })
                 .where(eq(wallet.id, updated.walletId));
             return updated;
         });
         const userId = await this.userIdForWallet(tx.walletId);
         this.events.emit('wallet.withdrawal.rejected', {
             userId,
-            amount: Number(tx.amount),
+            amount: tx.amount,
             currency: tx.currency,
             transactionId: tx.id,
             adminId,
@@ -677,8 +754,9 @@ export class WalletService {
     async getTransactions(userId, page, limit) {
         const db = this.drizzle.db;
         const [walletRecord] = await db.select().from(wallet).where(eq(wallet.userId, userId));
-        if (!walletRecord)
+        if (!walletRecord) {
             return { items: [], total: 0, page, limit };
+        }
         const where = eq(walletTransaction.walletId, walletRecord.id);
         const [txs, [{ n }]] = await Promise.all([
             db
@@ -694,7 +772,7 @@ export class WalletService {
             items: txs.map((tx) => ({
                 id: tx.id,
                 type: tx.type,
-                amount: Number(tx.amount),
+                amount: tx.amount,
                 currency: tx.currency,
                 status: tx.status,
                 createdAt: tx.createdAt.toISOString(),