/** * Sweeps on-chain deposits from user HD addresses to cold storage. */ import * as bip39 from 'bip39'; import { config } from '../config'; import { deriveTronFromMnemonic, derivePolygonFromMnemonic, 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'; const PLATFORM_MNEMONIC = process.env.PLATFORM_MNEMONIC || ''; const TRON_WALLET_TYPE_IDS = [1, 2]; const POLYGON_WALLET_TYPE_ID = 3; const MIN_TRX_FOR_TRC20_SWEEP = 3_000_000n; 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 deriveDepositPrivateKey(walletTypeId: number, derivationIndex: number): string { const mnemonic = getMnemonic(); if (TRON_WALLET_TYPE_IDS.includes(walletTypeId)) { return deriveTronFromMnemonic(mnemonic, derivationIndex).privateKey; } if (walletTypeId === POLYGON_WALLET_TYPE_ID) { return derivePolygonFromMnemonic(mnemonic, derivationIndex).privateKey; } throw new Error('Unsupported wallet type for sweep'); } export async function enqueueSweepAfterDeposit( userId: string, walletTypeId: number, amount: bigint, depositTransactionId: string ): Promise { 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 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); } async function ensureTronGasForTokenSweep(depositAddress: string): Promise { const trxBalance = await tronService.getTrxBalanceSun(depositAddress); if (trxBalance >= MIN_TRX_FOR_TRC20_SWEEP) return; const hot = await hotWalletRepository.getActiveHotWallet(1); if (!hot) throw new Error('No TRX 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 ensurePolygonGasForUsdcSweep(depositAddress: string, hotPrivateKey: string): Promise { 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 { const walletType = sweep.wallet_type_id === 1 ? await walletRepository.getWalletTypeByCode('TRX') : sweep.wallet_type_id === 2 ? await walletRepository.getWalletTypeByCode('USDT_TRC20') : await walletRepository.getWalletTypeByCode('USDC_POLYGON'); if (!walletType) throw new Error('Unknown wallet type'); const userWallet = await walletRepository.getUserWallet(sweep.user_id, sweep.wallet_type_id); if (!userWallet) throw new Error('User deposit wallet not found'); const amount = BigInt(sweep.amount); const privateKey = deriveDepositPrivateKey(sweep.wallet_type_id, userWallet.derivation_index); await depositSweepRepository.updateSweepStatus(sweep.id, 'broadcasting'); let txId: string; if (walletType.network === 'TRON') { const trc20Contract = walletType.code === 'USDT_TRC20' && 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); 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 === 'POLYGON') { const hot = await hotWalletRepository.getActiveHotWallet(POLYGON_WALLET_TYPE_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 }); } export async function processPendingSweeps(opts?: { unbatchedOnly?: boolean; batchId?: string; limit?: number; }): Promise { 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++; if (process.env.NODE_ENV !== 'production') { console.log(`[sweep] Completed sweep ${sweep.id} → cold`); } } 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; } export async function executeApprovedBatch(batchId: string): Promise { 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; }