games_app/backend/src/services/sweepService.ts

480 lines
18 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* Sweeps on-chain deposits from user HD addresses to cold storage.
*/
import * as bip39 from 'bip39';
import { config } from '../config';
import {
deriveTronFromMnemonic,
deriveEvmFromMnemonic,
decryptPrivateKey,
} from './hdWallet';
import * as walletRepository from '../repositories/walletRepository';
import * as coldWalletRepository from '../repositories/coldWalletRepository';
import * as depositSweepRepository from '../repositories/depositSweepRepository';
import * as depositSweepBatchRepository from '../repositories/depositSweepBatchRepository';
import * as hotWalletRepository from '../repositories/hotWalletRepository';
import * as tronService from './blockchain/tronService';
import * as polygonService from './blockchain/polygonService';
import * as bscService from './blockchain/bscService';
import { USDT_BEP20_CODE, USDT_TRC20_CODE } from './walletCapabilities';
const PLATFORM_MNEMONIC = process.env.PLATFORM_MNEMONIC || '';
const MIN_TRX_FOR_TRC20_SWEEP = 3_000_000n;
const MIN_BNB_WEI = 50_000_000_000_000n; // 0.00005 BNB
function getMnemonic(): string {
const raw = PLATFORM_MNEMONIC.trim();
if (!raw || !bip39.validateMnemonic(raw)) {
throw new Error('PLATFORM_MNEMONIC is not configured for sweeps');
}
return raw;
}
function minSweepAmount(): bigint {
return BigInt(config.treasury.sweepMinAmountRaw);
}
function normalizeChainAddress(network: string, address: string): string {
const a = address.trim();
if (network === 'BSC' || network === 'POLYGON' || a.startsWith('0x') || a.startsWith('0X')) {
return a.toLowerCase();
}
return a;
}
function addressesMatch(network: string, a: string, b: string): boolean {
return normalizeChainAddress(network, a) === normalizeChainAddress(network, b);
}
function isColdOnAllowlist(network: string, coldAddress: string): boolean {
const list = config.treasury.sweepColdAllowlist;
if (list.length === 0) return true;
const want = normalizeChainAddress(network, coldAddress);
return list.some((entry) => normalizeChainAddress(network, entry) === want);
}
function isAutoExecuteEligible(amount: bigint): boolean {
if (!config.treasury.sweepAutoExecute) return false;
const maxRaw = config.treasury.sweepAutoMaxAmountRaw;
if (maxRaw) {
try {
if (amount > BigInt(maxRaw)) return false;
} catch {
return false;
}
}
return true;
}
/**
* Re-validates destination + amount immediately before broadcast.
* Prevents sweeping to a cold address that changed / is not allowlisted.
*/
async function assertSweepSafeToExecute(sweep: depositSweepRepository.DepositSweepRow): Promise<{
network: string;
walletType: NonNullable<Awaited<ReturnType<typeof walletRepository.getWalletTypeById>>>;
}> {
const walletType = await walletRepository.getWalletTypeById(sweep.wallet_type_id);
if (!walletType) throw new Error('Unknown wallet type');
const amount = BigInt(sweep.amount);
if (amount < minSweepAmount()) {
throw new Error(`Sweep amount below SWEEP_MIN_AMOUNT_RAW (${amount} < ${minSweepAmount()})`);
}
const cold = await coldWalletRepository.getActiveColdWallet(sweep.wallet_type_id);
if (!cold) throw new Error('No active cold wallet for this network');
if (!addressesMatch(walletType.network, cold.address, sweep.to_cold_address)) {
throw new Error(
`Sweep destination mismatch: queued=${sweep.to_cold_address} activeCold=${cold.address}`
);
}
if (!isColdOnAllowlist(walletType.network, cold.address)) {
throw new Error(
`Cold address ${cold.address} is not in SWEEP_COLD_ALLOWLIST — refusing sweep`
);
}
// On-chain balance must cover the queued amount (guards against stale / wrong enqueue).
if (walletType.network === 'BSC' || walletType.code === USDT_BEP20_CODE) {
const contract = bscService.resolveUsdtContract(walletType.contract_address);
const bal = await bscService.getUsdtBalanceRaw(sweep.from_address, contract);
if (bal < amount) {
throw new Error(
`HD balance ${bal.toString()} < sweep amount ${amount.toString()} for ${sweep.from_address}`
);
}
} else if (walletType.network === 'TRON') {
const trc20Contract =
walletType.code === USDT_TRC20_CODE && config.blockchain.tron.usdtTrc20Contract
? config.blockchain.tron.usdtTrc20Contract
: walletType.contract_address;
if (trc20Contract) {
const bal = await tronService.getTrc20BalanceRaw(sweep.from_address, trc20Contract);
if (bal < amount) {
throw new Error(
`HD balance ${bal.toString()} < sweep amount ${amount.toString()} for ${sweep.from_address}`
);
}
}
}
return { network: walletType.network, walletType };
}
function deriveDepositPrivateKey(network: string, derivationIndex: number): string {
const mnemonic = getMnemonic();
if (network === 'TRON') {
return deriveTronFromMnemonic(mnemonic, derivationIndex).privateKey;
}
if (network === 'BSC' || network === 'POLYGON') {
return deriveEvmFromMnemonic(mnemonic, derivationIndex).privateKey;
}
throw new Error(`Unsupported network for sweep: ${network}`);
}
export async function enqueueSweepAfterDeposit(
userId: string,
walletTypeId: number,
amount: bigint,
depositTransactionId: string
): Promise<void> {
if (!config.treasury.sweepEnabled) return;
const existing = await depositSweepRepository.findByDepositTransactionId(depositTransactionId);
if (existing) return;
const cold = await coldWalletRepository.getActiveColdWallet(walletTypeId);
if (!cold) {
if (process.env.NODE_ENV !== 'production') {
console.warn(`[sweep] No cold wallet for type ${walletTypeId}; skipping enqueue`);
}
return;
}
const walletType = await walletRepository.getWalletTypeById(walletTypeId);
if (!walletType) return;
if (!isColdOnAllowlist(walletType.network, cold.address)) {
console.error(
`[sweep] Active cold ${cold.address} not in SWEEP_COLD_ALLOWLIST — not enqueueing`
);
return;
}
const userWallet = await walletRepository.getUserWallet(userId, walletTypeId);
if (!userWallet) return;
if (amount < minSweepAmount()) return;
const batch = await depositSweepBatchRepository.getOrCreateOpenBatch();
await depositSweepRepository.createSweep({
userId,
walletTypeId,
fromAddress: userWallet.address,
toColdAddress: cold.address,
amount,
depositTransactionId,
batchId: batch.id,
});
await depositSweepBatchRepository.incrementBatchCount(batch.id);
// Don't wait for the 1–2 min poll — run auto path right after enqueue.
if (isAutoExecuteEligible(amount)) {
void processAutoEligibleSweeps().catch((e) => {
console.error('[sweep] post-enqueue auto-execute error:', e);
});
}
}
export async function enqueueSweepsForCreditedHdBalances(): Promise<{
sweepEnabled: boolean;
enqueued: number;
alreadyQueued: number;
}> {
if (!config.treasury.sweepEnabled) {
return { sweepEnabled: false, enqueued: 0, alreadyQueued: 0 };
}
const { listPositiveSnapshots } = await import('../repositories/depositHdSnapshotRepository');
const { listCompletedDepositsToAddress } = await import('../repositories/transactionRepository');
const snapshots = await listPositiveSnapshots();
let enqueued = 0;
let alreadyQueued = 0;
for (const s of snapshots) {
if (!s.credited) continue;
const deposits = await listCompletedDepositsToAddress(s.address);
for (const deposit of deposits) {
const existing = await depositSweepRepository.findByDepositTransactionId(deposit.id);
if (existing) {
alreadyQueued += 1;
continue;
}
const meta = (deposit.metadata ?? {}) as Record<string, unknown>;
const chainRaw =
typeof meta.chain_amount === 'string'
? meta.chain_amount
: typeof meta.chainAmount === 'string'
? meta.chainAmount
: null;
const amount = chainRaw ? BigInt(chainRaw) : BigInt(deposit.amount);
if (amount <= 0n) continue;
await enqueueSweepAfterDeposit(deposit.user_id, s.wallet_type_id, amount, deposit.id);
const after = await depositSweepRepository.findByDepositTransactionId(deposit.id);
if (after) enqueued += 1;
}
}
return { sweepEnabled: true, enqueued, alreadyQueued };
}
async function ensureTronGasForTokenSweep(depositAddress: string, usdtWalletTypeId: number): Promise<void> {
const trxBalance = await tronService.getTrxBalanceSun(depositAddress);
if (trxBalance >= MIN_TRX_FOR_TRC20_SWEEP) return;
// Prefer USDT TRC20 hot wallet (same TRON address holds TRX for gas)
const hot = await hotWalletRepository.getActiveHotWallet(usdtWalletTypeId);
if (!hot) throw new Error('No TRON hot wallet for gas top-up');
const hotKey = decryptPrivateKey(hot.encrypted_private_key);
const topUp = BigInt(config.treasury.tronGasTopUpSun);
await tronService.sendTrx(hotKey, depositAddress, topUp);
}
async function ensureBscGasForUsdtSweep(depositAddress: string, hotPrivateKey: string): Promise<void> {
const bnb = await bscService.getNativeBalanceWei(depositAddress);
if (bnb >= MIN_BNB_WEI) return;
const topUp = BigInt(config.blockchain.bsc.gasTopUpWei);
await bscService.sendBnb(hotPrivateKey, depositAddress, topUp);
}
async function ensurePolygonGasForUsdcSweep(depositAddress: string, hotPrivateKey: string): Promise<void> {
const matic = await polygonService.getNativeBalanceWei(depositAddress);
const minGas = 50_000_000_000_000_000n;
if (matic >= minGas) return;
const topUp = BigInt(config.treasury.polygonGasTopUpWei);
await polygonService.sendMatic(hotPrivateKey, depositAddress, topUp);
}
async function executeSweep(sweep: depositSweepRepository.DepositSweepRow): Promise<void> {
const { walletType } = await assertSweepSafeToExecute(sweep);
const userWallet = await walletRepository.getUserWallet(sweep.user_id, sweep.wallet_type_id);
if (!userWallet) throw new Error('User deposit wallet not found');
if (!addressesMatch(walletType.network, userWallet.address, sweep.from_address)) {
throw new Error(
`Sweep from_address mismatch: queued=${sweep.from_address} userWallet=${userWallet.address}`
);
}
const amount = BigInt(sweep.amount);
const privateKey = deriveDepositPrivateKey(walletType.network, userWallet.derivation_index);
await depositSweepRepository.updateSweepStatus(sweep.id, 'broadcasting');
let txId: string;
if (walletType.network === 'TRON') {
const trc20Contract =
walletType.code === USDT_TRC20_CODE && config.blockchain.tron.usdtTrc20Contract
? config.blockchain.tron.usdtTrc20Contract
: walletType.contract_address;
if (trc20Contract) {
await depositSweepRepository.updateSweepStatus(sweep.id, 'gas_funding');
await ensureTronGasForTokenSweep(sweep.from_address, walletType.id);
await depositSweepRepository.updateSweepStatus(sweep.id, 'broadcasting');
txId = await tronService.sendTrc20(
privateKey,
trc20Contract,
sweep.to_cold_address,
amount
);
} else {
txId = await tronService.sendTrx(privateKey, sweep.to_cold_address, amount);
}
} else if (walletType.network === 'BSC' || walletType.code === USDT_BEP20_CODE) {
const hot = await hotWalletRepository.getActiveHotWallet(walletType.id);
if (!hot) throw new Error('No BSC hot wallet for gas');
const hotKey = decryptPrivateKey(hot.encrypted_private_key);
await depositSweepRepository.updateSweepStatus(sweep.id, 'gas_funding');
await ensureBscGasForUsdtSweep(sweep.from_address, hotKey);
await depositSweepRepository.updateSweepStatus(sweep.id, 'broadcasting');
const contract = bscService.resolveUsdtContract(walletType.contract_address);
txId = await bscService.sendUsdt(privateKey, contract, sweep.to_cold_address, amount);
} else if (walletType.network === 'POLYGON') {
const hot = await hotWalletRepository.getActiveHotWallet(walletType.id);
if (!hot) throw new Error('No Polygon hot wallet for gas');
const hotKey = decryptPrivateKey(hot.encrypted_private_key);
await depositSweepRepository.updateSweepStatus(sweep.id, 'gas_funding');
await ensurePolygonGasForUsdcSweep(sweep.from_address, hotKey);
await depositSweepRepository.updateSweepStatus(sweep.id, 'broadcasting');
txId = await polygonService.sendUsdc(privateKey, sweep.to_cold_address, amount);
} else {
throw new Error('Unsupported network');
}
await depositSweepRepository.updateSweepStatus(sweep.id, 'completed', { blockchainTxId: txId });
// Treasury "USDT still on HD" reads deposit_hd_snapshots; refresh so the row clears
// without waiting for the next deposit-monitor poll / manual Scan & credit.
try {
let remaining = 0n;
if (walletType.network === 'TRON') {
const trc20Contract =
walletType.code === USDT_TRC20_CODE && config.blockchain.tron.usdtTrc20Contract
? config.blockchain.tron.usdtTrc20Contract
: walletType.contract_address;
if (trc20Contract) {
remaining = await tronService.getTrc20BalanceRaw(sweep.from_address, trc20Contract);
}
} else if (walletType.network === 'BSC' || walletType.code === USDT_BEP20_CODE) {
const contract = bscService.resolveUsdtContract(walletType.contract_address);
remaining = await bscService.getUsdtBalanceRaw(sweep.from_address, contract);
} else if (walletType.network === 'POLYGON') {
remaining = await polygonService.getUsdcBalanceRaw(sweep.from_address);
}
const { upsertSnapshot } = await import('../repositories/depositHdSnapshotRepository');
await upsertSnapshot({
userId: sweep.user_id,
walletTypeId: sweep.wallet_type_id,
address: sweep.from_address,
onChainAmount: remaining,
});
} catch (e) {
console.warn(
`[sweep] HD balance re-read failed after sweep ${sweep.id}:`,
e instanceof Error ? e.message : e
);
try {
const { decreaseSnapshotBy } = await import('../repositories/depositHdSnapshotRepository');
await decreaseSnapshotBy({
userId: sweep.user_id,
walletTypeId: sweep.wallet_type_id,
amount,
});
} catch (e2) {
console.warn(
`[sweep] HD snapshot decrease failed after sweep ${sweep.id}:`,
e2 instanceof Error ? e2.message : e2
);
}
}
}
export async function processPendingSweeps(opts?: {
unbatchedOnly?: boolean;
batchId?: string;
limit?: number;
}): Promise<number> {
if (!config.treasury.sweepEnabled) return 0;
const pending = await depositSweepRepository.listPendingSweeps(opts?.limit ?? 10, {
unbatchedOnly: opts?.unbatchedOnly,
batchId: opts?.batchId,
});
let processed = 0;
for (const sweep of pending) {
try {
await executeSweep(sweep);
processed++;
console.log(`[sweep] Completed sweep ${sweep.id} → ${sweep.to_cold_address}`);
} catch (e) {
const msg = e instanceof Error ? e.message : String(e);
console.error(`[sweep] Failed sweep ${sweep.id}:`, msg);
await depositSweepRepository.updateSweepStatus(sweep.id, 'failed', { errorMessage: msg });
}
}
return processed;
}
/**
* Auto path: execute pending sweeps that pass SWEEP_AUTO_EXECUTE + optional max amount,
* without going through Approvals. Large sweeps (over max) stay queued for manual approval.
*/
export async function processAutoEligibleSweeps(): Promise<number> {
if (!config.treasury.sweepEnabled) {
console.warn('[sweep] auto-execute skipped: SWEEP_ENABLED is not true');
return 0;
}
if (!config.treasury.sweepAutoExecute) {
console.warn('[sweep] auto-execute skipped: SWEEP_AUTO_EXECUTE is not true');
return 0;
}
const pending = await depositSweepRepository.listPendingSweeps(25);
if (pending.length === 0) return 0;
console.log(`[sweep] auto-execute: ${pending.length} pending sweep(s) to consider`);
let processed = 0;
let skippedMax = 0;
for (const sweep of pending) {
const amount = BigInt(sweep.amount);
if (!isAutoExecuteEligible(amount)) {
skippedMax += 1;
console.warn(
`[sweep] skip ${sweep.id}: amount ${sweep.amount} above SWEEP_AUTO_MAX_AMOUNT_RAW=` +
`${config.treasury.sweepAutoMaxAmountRaw || '(unset)'} (BEP20 uses 18 decimals)`
);
continue;
}
try {
await executeSweep(sweep);
processed += 1;
console.log(
`[sweep] auto-executed ${sweep.id} amount=${sweep.amount} → ${sweep.to_cold_address}`
);
try {
const auditLogRepository = await import('../repositories/auditLogRepository');
await auditLogRepository.create({
userId: sweep.user_id,
action: 'sweep_auto_executed',
resourceType: 'deposit_sweep',
resourceId: sweep.id,
metadata: {
amount: sweep.amount,
from: sweep.from_address,
to: sweep.to_cold_address,
walletTypeId: sweep.wallet_type_id,
},
});
} catch {
// audit must not block sweep success
}
} catch (e) {
const msg = e instanceof Error ? e.message : String(e);
console.error(`[sweep] auto-execute failed ${sweep.id}:`, msg);
await depositSweepRepository.updateSweepStatus(sweep.id, 'failed', { errorMessage: msg });
}
}
if (skippedMax > 0) {
console.warn(
`[sweep] ${skippedMax} sweep(s) left for Approvals (over SWEEP_AUTO_MAX_AMOUNT_RAW)`
);
}
return processed;
}
export async function executeApprovedBatch(batchId: string): Promise<number> {
await depositSweepBatchRepository.markBatchStatus(batchId, 'executing');
try {
const processed = await processPendingSweeps({ batchId, limit: 100 });
await depositSweepBatchRepository.markBatchStatus(batchId, 'completed');
return processed;
} catch (e) {
await depositSweepBatchRepository.markBatchStatus(batchId, 'failed');
throw e;
}
}
export function getSweepPollIntervalMs(): number {
return config.treasury.sweepPollIntervalMs;
}