diff --git a/.env.example b/.env.example index 73c11710..bd27df47 100644 --- a/.env.example +++ b/.env.example @@ -84,6 +84,12 @@ USDC_POLYGON_CONTRACT= ALLOW_WITHDRAWALS=false # Treasury sweeps (deposit HD → cold). Also wire these in docker-compose (recreate backend after change). SWEEP_ENABLED=false +# true = auto HD→cold without Approvals (recommended only with SWEEP_COLD_ALLOWLIST set) +# SWEEP_AUTO_EXECUTE=false +# Optional raw max for auto path; above this still needs Approvals (BEP20: 18 decimals, e.g. 100 USDT = 100000000000000000000) +# SWEEP_AUTO_MAX_AMOUNT_RAW= +# Pin allowed cold destination(s); blocks sweeps if DB cold is changed to another address +# SWEEP_COLD_ALLOWLIST=0xYourColdAddress # Min on-chain raw units to enqueue (TRC20: 1e6 = 1 USDT; BEP20 uses 18-dec chain amount so 1e6 is tiny) SWEEP_MIN_AMOUNT_RAW=1000000 # SWEEP_BSC_GAS_TOPUP_WEI=1000000000000000 diff --git a/backend/src/bootstrap/appBootstrap.ts b/backend/src/bootstrap/appBootstrap.ts index 8952d17b..1a20c534 100644 --- a/backend/src/bootstrap/appBootstrap.ts +++ b/backend/src/bootstrap/appBootstrap.ts @@ -14,6 +14,7 @@ import { createSweepBatchApprovalRequests, SWEEP_BATCH_INTERVAL_MS, } from '../services/sweepBatchService'; +import { processAutoEligibleSweeps, getSweepPollIntervalMs } from '../services/sweepService'; import { ensureCountriesSeeded } from '../services/countryService'; import { scheduleAdminStatsBackfill } from '../services/userAdminStatsService'; import { startAdminExportWorker } from '../services/adminUserExportService'; @@ -95,14 +96,24 @@ function startDbTamperMonitor(): void { function startSweepBatchMonitor(): void { const run = async () => { try { + if (config.treasury.sweepEnabled && config.treasury.sweepAutoExecute) { + const auto = await processAutoEligibleSweeps(); + if (auto > 0) { + console.log(`[sweep] auto-executed ${auto} sweep(s)`); + } + } const n = await createSweepBatchApprovalRequests(); - if (n > 0 && process.env.NODE_ENV !== 'production') { + if (n > 0) { console.log(`[sweep-batch] Enqueued ${n} batch approval request(s)`); } } catch (e) { console.error('Sweep batch job error:', e); } - setTimeout(run, SWEEP_BATCH_INTERVAL_MS); + const nextMs = + config.treasury.sweepEnabled && config.treasury.sweepAutoExecute + ? Math.min(SWEEP_BATCH_INTERVAL_MS, getSweepPollIntervalMs()) + : SWEEP_BATCH_INTERVAL_MS; + setTimeout(run, nextMs); }; setTimeout(run, 60_000); } diff --git a/backend/src/config/index.ts b/backend/src/config/index.ts index 68dc8832..beee97a1 100644 --- a/backend/src/config/index.ts +++ b/backend/src/config/index.ts @@ -174,6 +174,24 @@ export const config = { treasury: { /** Moves on-chain deposits from user addresses to cold storage */ sweepEnabled: process.env.SWEEP_ENABLED === 'true', + /** + * When true, pending sweeps execute on-chain without Approvals (after safety checks). + * Default false — keep human approval for cold destination / amount review. + */ + sweepAutoExecute: process.env.SWEEP_AUTO_EXECUTE === 'true', + /** + * Optional raw-unit cap for auto-execute. Above this amount, sweep stays pending + * for Submit sweeps → Approvals. Empty = no cap when SWEEP_AUTO_EXECUTE=true. + */ + sweepAutoMaxAmountRaw: (process.env.SWEEP_AUTO_MAX_AMOUNT_RAW || '').trim(), + /** + * Optional comma-separated cold addresses allowed as sweep destinations (EVM lowercased). + * When set, active cold must match; blocks sweeps if DB cold was changed to an unknown address. + */ + sweepColdAllowlist: (process.env.SWEEP_COLD_ALLOWLIST || '') + .split(',') + .map((s) => s.trim()) + .filter(Boolean), sweepPollIntervalMs: parseInt(process.env.SWEEP_POLL_INTERVAL_MS || '120000', 10), /** Minimum token amount (raw units) to sweep */ sweepMinAmountRaw: process.env.SWEEP_MIN_AMOUNT_RAW || '1000000', diff --git a/backend/src/services/sweepService.ts b/backend/src/services/sweepService.ts index a278623e..c1795d97 100644 --- a/backend/src/services/sweepService.ts +++ b/backend/src/services/sweepService.ts @@ -35,6 +35,96 @@ 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>>; +}> { + 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') { @@ -65,6 +155,15 @@ export async function enqueueSweepAfterDeposit( 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; @@ -153,11 +252,15 @@ async function ensurePolygonGasForUsdcSweep(depositAddress: string, hotPrivateKe } async function executeSweep(sweep: depositSweepRepository.DepositSweepRow): Promise { - const walletType = await walletRepository.getWalletTypeById(sweep.wallet_type_id); - if (!walletType) throw new Error('Unknown wallet type'); + 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); @@ -271,9 +374,7 @@ export async function processPendingSweeps(opts?: { try { await executeSweep(sweep); processed++; - if (process.env.NODE_ENV !== 'production') { - console.log(`[sweep] Completed sweep ${sweep.id} → cold`); - } + 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); @@ -284,6 +385,52 @@ export async function processPendingSweeps(opts?: { 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 { + if (!config.treasury.sweepEnabled || !config.treasury.sweepAutoExecute) return 0; + + const pending = await depositSweepRepository.listPendingSweeps(25); + let processed = 0; + + for (const sweep of pending) { + const amount = BigInt(sweep.amount); + if (!isAutoExecuteEligible(amount)) 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 }); + } + } + + return processed; +} + export async function executeApprovedBatch(batchId: string): Promise { await depositSweepBatchRepository.markBatchStatus(batchId, 'executing'); try { diff --git a/docker-compose.yml b/docker-compose.yml index fdee2a80..e1831bc5 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -56,6 +56,12 @@ x-backend-common: &backend-common ALLOW_WITHDRAWALS: ${ALLOW_WITHDRAWALS:-false} # Treasury: auto-enqueue deposit → cold sweeps (requires active cold wallet in Admin → Treasury) SWEEP_ENABLED: ${SWEEP_ENABLED:-false} + # true = sweep HD→cold without Approvals (still validates cold allowlist / balances) + SWEEP_AUTO_EXECUTE: ${SWEEP_AUTO_EXECUTE:-false} + # Optional: auto only below this raw amount; larger still need Approvals + SWEEP_AUTO_MAX_AMOUNT_RAW: ${SWEEP_AUTO_MAX_AMOUNT_RAW:-} + # Optional: comma-separated allowed cold addresses (recommended if auto-execute) + SWEEP_COLD_ALLOWLIST: ${SWEEP_COLD_ALLOWLIST:-} SWEEP_MIN_AMOUNT_RAW: ${SWEEP_MIN_AMOUNT_RAW:-1000000} SWEEP_POLL_INTERVAL_MS: ${SWEEP_POLL_INTERVAL_MS:-120000} SWEEP_BSC_GAS_TOPUP_WEI: ${SWEEP_BSC_GAS_TOPUP_WEI:-1000000000000000} diff --git a/docs/DEPLOY-VPS.md b/docs/DEPLOY-VPS.md index 1df3e670..4fef2dc9 100644 --- a/docs/DEPLOY-VPS.md +++ b/docs/DEPLOY-VPS.md @@ -81,6 +81,9 @@ nano .env # ou vim | `USDT_BEP20_CONTRACT` | Laisser **vide** en mainnet (USDT officiel BSC en DB) | | `ALLOW_WITHDRAWALS` | `false` jusqu’à validation des dépôts (le kill-switch admin Settings prime aussi) | | `SWEEP_ENABLED` | `false` jusqu’au test cold/sweep ; passer à `true` + cold wallet (voir section trésorerie) | +| `SWEEP_AUTO_EXECUTE` | `false` (défaut) = Submit + Approvals ; `true` = sweep HD→cold automatique après contrôles | +| `SWEEP_AUTO_MAX_AMOUNT_RAW` | Optionnel — au-dessus de ce montant (raw), l’approbation manuelle reste obligatoire | +| `SWEEP_COLD_ALLOWLIST` | Optionnel mais **recommandé** avec auto : adresses cold autorisées (séparées par virgule) | | `APP_PUBLIC_URL` | Ex. HTTP test : `http://prediqo.redirectme.net:9080` · HTTPS : `https://…:9443` | | `CORS_ORIGINS` | Même origine que le front (schéma + hôte + port) | | `VITE_API_BASE_URL` | Même URL de base que `APP_PUBLIC_URL` (sans `/api`) — **rebuild** front après changement | @@ -444,12 +447,17 @@ Objectif : valider le circuit **Dépôt user → adresse HD dépôt → Sweep ```env SWEEP_ENABLED=true +# Optionnel — sweep sans Approvals (garder false si vous voulez une revue humaine) : +# SWEEP_AUTO_EXECUTE=true +# SWEEP_COLD_ALLOWLIST=0xVotreColdBep20 +# SWEEP_AUTO_MAX_AMOUNT_RAW=100000000000000000000 # optionnel : min on-chain (défaut 1000000 — largement sous 1 USDT BEP20 à 18 déc.) # SWEEP_MIN_AMOUNT_RAW=1000000 # top-up BNB vers l’adresse de dépôt avant transfer USDT (défaut 0.001 BNB) # SWEEP_BSC_GAS_TOPUP_WEI=1000000000000000 ``` +> **Approbation vs auto :** par défaut, « Submit sweeps for approval » + Approvals est un **contrôle ops** (revoir destination / montant). Ce n’est pas ce qui protège contre une compromission totale du serveur (`PLATFORM_MNEMONIC` suffit déjà à signer). Avec `SWEEP_AUTO_EXECUTE=true`, le job exécute les sweeps éligibles après vérif cold actif = allowlist, solde HD ≥ montant, min amount. Les montants au-dessus de `SWEEP_AUTO_MAX_AMOUNT_RAW` restent manuels. 4. Recréer le backend pour injecter les vars (`docker-compose` les passe désormais) : ```bash diff --git a/prediqo_web/src/shared/i18n/locales/en.ts b/prediqo_web/src/shared/i18n/locales/en.ts index 401e297b..81bed270 100644 --- a/prediqo_web/src/shared/i18n/locales/en.ts +++ b/prediqo_web/src/shared/i18n/locales/en.ts @@ -1538,7 +1538,7 @@ export const en = { pendingSweeps: '{{count}} pending sweeps', failedSweeps: '{{count}} failed sweeps', sweepDisabledHint: - 'Set SWEEP_ENABLED=true in the VPS .env (wired via docker-compose), recreate the backend container, then save a cold wallet address below. New deposits enqueue sweeps automatically; approve batches under Approvals.', + 'Set SWEEP_ENABLED=true in the VPS .env (wired via docker-compose), recreate the backend container, then save a cold wallet address below. New deposits enqueue sweeps; approve under Approvals — or set SWEEP_AUTO_EXECUTE=true (with SWEEP_COLD_ALLOWLIST) for hands-free HD→cold.', coldWallet: 'Cold wallet', hotWallet: 'Hot wallet', address: 'Address', diff --git a/prediqo_web/src/shared/i18n/locales/fr.ts b/prediqo_web/src/shared/i18n/locales/fr.ts index 927c54db..e1031851 100644 --- a/prediqo_web/src/shared/i18n/locales/fr.ts +++ b/prediqo_web/src/shared/i18n/locales/fr.ts @@ -1554,7 +1554,7 @@ export const fr = { pendingSweeps: '{{count}} sweep(s) en attente', failedSweeps: '{{count}} sweep(s) échoué(s)', sweepDisabledHint: - 'Définissez SWEEP_ENABLED=true dans le .env VPS (passé via docker-compose), recréez le conteneur backend, puis enregistrez une adresse cold ci-dessous. Les nouveaux dépôts enfilent un sweep ; approuvez les lots sous Approvals.', + 'Définissez SWEEP_ENABLED=true dans le .env VPS (passé via docker-compose), recréez le conteneur backend, puis enregistrez une adresse cold ci-dessous. Les nouveaux dépôts enfilent un sweep ; Approvals — ou SWEEP_AUTO_EXECUTE=true (avec SWEEP_COLD_ALLOWLIST) pour un HD→cold sans clic.', coldWallet: 'Cold wallet', hotWallet: 'Hot wallet', address: 'Adresse',