317 lines
14 KiB
JavaScript
317 lines
14 KiB
JavaScript
"use strict";
|
|
/**
|
|
* On-chain withdrawal service.
|
|
* Debits unified USDT ledger (USDT_TRC20, 6 decimals); pays from the chosen
|
|
* rail hot wallet (TRC20 or BEP20). Network need not match deposit history —
|
|
* liquidity is gated by hot float (USDT + gas), not user inventory.
|
|
*/
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (this && this.__importStar) || (function () {
|
|
var ownKeys = function(o) {
|
|
ownKeys = Object.getOwnPropertyNames || function (o) {
|
|
var ar = [];
|
|
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
|
return ar;
|
|
};
|
|
return ownKeys(o);
|
|
};
|
|
return function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.SecurityBlockedError = void 0;
|
|
exports.requestWithdrawal = requestWithdrawal;
|
|
const config_1 = require("../config");
|
|
const hdWallet_1 = require("./hdWallet");
|
|
const ledgerRepository = __importStar(require("../repositories/ledgerRepository"));
|
|
const transactionRepository = __importStar(require("../repositories/transactionRepository"));
|
|
const withdrawalLockRepository = __importStar(require("../repositories/withdrawalLockRepository"));
|
|
const hotWalletRepository = __importStar(require("../repositories/hotWalletRepository"));
|
|
const auditLogRepository = __importStar(require("../repositories/auditLogRepository"));
|
|
const walletRepository = __importStar(require("../repositories/walletRepository"));
|
|
const settingsRepository = __importStar(require("../repositories/settingsRepository"));
|
|
const tronService = __importStar(require("./blockchain/tronService"));
|
|
const polygonService = __importStar(require("./blockchain/polygonService"));
|
|
const bscService = __importStar(require("./blockchain/bscService"));
|
|
const withdrawalFee_1 = require("../utils/withdrawalFee");
|
|
const securityService_1 = require("./securityService");
|
|
Object.defineProperty(exports, "SecurityBlockedError", { enumerable: true, get: function () { return securityService_1.SecurityBlockedError; } });
|
|
const authService = __importStar(require("./authService"));
|
|
const userAdminStatsService_1 = require("./userAdminStatsService");
|
|
const referralService = __importStar(require("./referralService"));
|
|
const withdrawalLimits_1 = require("../utils/withdrawalLimits");
|
|
const walletCapabilities_1 = require("./walletCapabilities");
|
|
const usdtUnits_1 = require("../utils/usdtUnits");
|
|
const hotLiquidityService_1 = require("./hotLiquidityService");
|
|
function assertPayoutAddress(network, toAddress) {
|
|
const a = toAddress.trim();
|
|
if (network === 'BSC') {
|
|
if (!/^0x[a-fA-F0-9]{40}$/.test(a)) {
|
|
throw new Error('Invalid BEP20 address. Use a 0x… address on BNB Smart Chain.');
|
|
}
|
|
return;
|
|
}
|
|
if (!/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(a)) {
|
|
throw new Error('Invalid TRC20 address. Use a T… address on TRON.');
|
|
}
|
|
}
|
|
async function assertWithdrawalWithinLimits(userId, railWalletType, amountRaw, feeRaw, settings) {
|
|
const amountUsd = (0, withdrawalLimits_1.rawAmountToUsdApprox)(walletCapabilities_1.USDT_TRC20_CODE, amountRaw, usdtUnits_1.LEDGER_USDT_DECIMALS);
|
|
const feeUsd = (0, withdrawalLimits_1.rawAmountToUsdApprox)(walletCapabilities_1.USDT_TRC20_CODE, feeRaw, usdtUnits_1.LEDGER_USDT_DECIMALS);
|
|
const totalUsd = amountUsd + feeUsd;
|
|
const startOfUtcDay = new Date();
|
|
startOfUtcDay.setUTCHours(0, 0, 0, 0);
|
|
const rows = await transactionRepository.listWithdrawalsSince(userId, startOfUtcDay);
|
|
let usedUsd = 0;
|
|
for (const row of rows) {
|
|
usedUsd += (0, withdrawalLimits_1.rawAmountToUsdApprox)(row.code, BigInt(row.amount), row.decimals);
|
|
usedUsd += (0, withdrawalLimits_1.rawAmountToUsdApprox)(row.code, BigInt(row.fee || '0'), row.decimals);
|
|
}
|
|
if (usedUsd + totalUsd > settings.daily_withdrawal_limit_usd) {
|
|
const err = new Error(`Daily withdrawal limit exceeded ($${settings.daily_withdrawal_limit_usd} USD per UTC day).`);
|
|
err.code = 'DAILY_WITHDRAWAL_LIMIT_EXCEEDED';
|
|
throw err;
|
|
}
|
|
if (amountUsd >= settings.large_withdrawal_threshold_usd) {
|
|
await auditLogRepository.create({
|
|
userId,
|
|
action: 'large_withdrawal_requested',
|
|
metadata: {
|
|
amountUsd,
|
|
thresholdUsd: settings.large_withdrawal_threshold_usd,
|
|
walletType: railWalletType.code,
|
|
amount: amountRaw.toString(),
|
|
},
|
|
});
|
|
void (0, securityService_1.raiseAlert)({
|
|
userId,
|
|
severity: 'medium',
|
|
alertType: 'large_withdrawal_requested',
|
|
title: 'Large withdrawal requested',
|
|
details: `User requested $${amountUsd.toFixed(2)} withdrawal (threshold $${settings.large_withdrawal_threshold_usd}).`,
|
|
metadata: {
|
|
amountUsd,
|
|
thresholdUsd: settings.large_withdrawal_threshold_usd,
|
|
walletType: railWalletType.code,
|
|
},
|
|
}).catch((e) => console.error('[withdrawal] large withdrawal alert failed:', e));
|
|
}
|
|
}
|
|
/**
|
|
* Submits a withdrawal: locks unified ledger, verifies hot float, pays from rail hot wallet.
|
|
* `walletTypeCode` selects the payout rail (USDT_TRC20 or USDT_BEP20).
|
|
* `amountRaw` is always in ledger micro-USDT (6 decimals).
|
|
*/
|
|
async function requestWithdrawal(userId, walletTypeCode, toAddress, amountRaw, totpCode) {
|
|
const settings = await settingsRepository.getSettings();
|
|
if (!settings.allow_withdrawals) {
|
|
const err = new Error('Withdrawals are disabled by server configuration (enable in Admin → Settings).');
|
|
err.code = 'WITHDRAWALS_DISABLED';
|
|
throw err;
|
|
}
|
|
await authService.assertWithdrawalSecondFactor(userId, totpCode);
|
|
await (0, securityService_1.assertUserCanWithdraw)(userId);
|
|
const railWalletType = await walletRepository.getWalletTypeByCode(walletTypeCode);
|
|
if (!railWalletType)
|
|
throw new Error('Unknown wallet type');
|
|
if (!(0, walletCapabilities_1.isSupportedUsdtCode)(walletTypeCode)) {
|
|
throw new Error(`Withdrawals are only supported for USDT networks`);
|
|
}
|
|
const network = (0, usdtUnits_1.networkForWalletCode)(walletTypeCode);
|
|
if (!network)
|
|
throw new Error('Unsupported withdrawal network');
|
|
const caps = (0, walletCapabilities_1.enrichWalletType)(railWalletType, settings);
|
|
if (!caps.withdrawEnabled) {
|
|
const err = new Error(`Withdrawals are disabled for ${walletTypeCode}`);
|
|
err.code = 'WITHDRAWAL_NETWORK_DISABLED';
|
|
throw err;
|
|
}
|
|
if (amountRaw <= 0n)
|
|
throw new Error('Invalid amount');
|
|
assertPayoutAddress(network, toAddress);
|
|
const ledgerWalletType = await walletRepository.getWalletTypeByCode(walletCapabilities_1.USDT_TRC20_CODE);
|
|
if (!ledgerWalletType)
|
|
throw new Error('USDT ledger wallet type not configured');
|
|
const feeRaw = (0, withdrawalFee_1.getWithdrawalNetworkFeeRaw)(settings, usdtUnits_1.LEDGER_USDT_DECIMALS);
|
|
const totalDebit = amountRaw + feeRaw;
|
|
await assertWithdrawalWithinLimits(userId, railWalletType, amountRaw, feeRaw, settings);
|
|
const account = await ledgerRepository.getOrCreateAccount(userId, ledgerWalletType.id);
|
|
const available = BigInt(account.available_balance);
|
|
const locked = await withdrawalLockRepository.getLockedAmount(userId, ledgerWalletType.id);
|
|
if (available < totalDebit + locked) {
|
|
const err = new Error(feeRaw > 0n
|
|
? 'Insufficient balance (withdrawal amount + network fee)'
|
|
: 'Insufficient balance');
|
|
err.code = 'INSUFFICIENT_BALANCE';
|
|
throw err;
|
|
}
|
|
const hotWallet = await hotWalletRepository.getActiveHotWallet(railWalletType.id);
|
|
if (!hotWallet)
|
|
throw new Error('Withdrawal temporarily unavailable');
|
|
if (network === 'TRON' || network === 'BSC') {
|
|
await (0, hotLiquidityService_1.assertHotWalletCanPay)({
|
|
network,
|
|
hotAddress: hotWallet.address,
|
|
ledgerAmountRaw: amountRaw,
|
|
usdtContract: railWalletType.contract_address || '',
|
|
});
|
|
}
|
|
await ledgerRepository.lockBalance(account.id, totalDebit);
|
|
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(userId);
|
|
const tx = await transactionRepository.create({
|
|
userId,
|
|
walletTypeId: ledgerWalletType.id,
|
|
type: 'withdrawal',
|
|
amount: amountRaw,
|
|
fee: feeRaw,
|
|
status: 'pending',
|
|
toAddress,
|
|
requiredConfirmations: railWalletType.network === 'TRON'
|
|
? config_1.config.blockchain.tron.confirmations
|
|
: railWalletType.network === 'BSC'
|
|
? config_1.config.blockchain.bsc.confirmations
|
|
: config_1.config.blockchain.polygon.confirmations,
|
|
metadata: {
|
|
rail_wallet_type: walletTypeCode,
|
|
network,
|
|
},
|
|
});
|
|
await withdrawalLockRepository.create({
|
|
userId,
|
|
walletTypeId: ledgerWalletType.id,
|
|
transactionId: tx.id,
|
|
amount: totalDebit,
|
|
});
|
|
await auditLogRepository.create({
|
|
userId,
|
|
action: 'withdrawal_requested',
|
|
resourceType: 'transaction',
|
|
resourceId: tx.id,
|
|
metadata: {
|
|
amount: amountRaw.toString(),
|
|
fee: feeRaw.toString(),
|
|
toAddress,
|
|
walletType: walletTypeCode,
|
|
network,
|
|
},
|
|
});
|
|
let blockchainTxId = null;
|
|
try {
|
|
const privateKey = (0, hdWallet_1.decryptPrivateKey)(hotWallet.encrypted_private_key);
|
|
await transactionRepository.updateStatus(tx.id, 'broadcasting');
|
|
if (railWalletType.network === 'TRON') {
|
|
const trc20Contract = config_1.config.blockchain.tron.usdtTrc20Contract || railWalletType.contract_address;
|
|
if (!trc20Contract)
|
|
throw new Error('USDT TRC20 contract not configured');
|
|
blockchainTxId = await tronService.sendTrc20(privateKey, trc20Contract, toAddress, amountRaw);
|
|
}
|
|
else if (railWalletType.network === 'BSC') {
|
|
const contract = bscService.resolveUsdtContract(railWalletType.contract_address);
|
|
const chainAmount = (0, usdtUnits_1.scaleLedgerToChain)(amountRaw, usdtUnits_1.BEP20_USDT_DECIMALS);
|
|
blockchainTxId = await bscService.sendUsdt(privateKey, contract, toAddress, chainAmount);
|
|
}
|
|
else if (railWalletType.network === 'POLYGON') {
|
|
blockchainTxId = await polygonService.sendUsdc(privateKey, toAddress, amountRaw);
|
|
}
|
|
else {
|
|
throw new Error('Unsupported network');
|
|
}
|
|
await transactionRepository.updateStatus(tx.id, 'confirming', 0, blockchainTxId);
|
|
try {
|
|
await ledgerRepository.finalizeWithdrawalFromLocked(account.id, totalDebit, tx.id);
|
|
await withdrawalLockRepository.deleteByTransactionId(tx.id);
|
|
await transactionRepository.updateStatus(tx.id, 'completed', 1);
|
|
}
|
|
catch (ledgerErr) {
|
|
await transactionRepository.updateStatus(tx.id, 'ledger_finalize_failed', 1, blockchainTxId);
|
|
await (0, securityService_1.raiseAlert)({
|
|
userId,
|
|
severity: 'critical',
|
|
alertType: 'withdrawal_ledger_finalize_failed',
|
|
title: 'Withdrawal broadcast succeeded but ledger finalization failed',
|
|
details: `transaction=${tx.id}, blockchain_tx=${blockchainTxId}, amount=${amountRaw.toString()}, fee=${feeRaw.toString()}. ` +
|
|
`Funds remain locked; manual reconciliation required.`,
|
|
metadata: {
|
|
transactionId: tx.id,
|
|
blockchainTxId,
|
|
amount: amountRaw.toString(),
|
|
fee: feeRaw.toString(),
|
|
},
|
|
suspendUser: true,
|
|
});
|
|
throw ledgerErr;
|
|
}
|
|
await auditLogRepository.create({
|
|
userId,
|
|
action: 'withdrawal_completed',
|
|
resourceType: 'transaction',
|
|
resourceId: tx.id,
|
|
metadata: {
|
|
amount: amountRaw.toString(),
|
|
fee: feeRaw.toString(),
|
|
totalDebited: totalDebit.toString(),
|
|
toAddress,
|
|
blockchainTxId,
|
|
network,
|
|
},
|
|
});
|
|
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(userId);
|
|
try {
|
|
await referralService.processWithdrawalReferralCommissions({
|
|
userId,
|
|
withdrawalTransactionId: tx.id,
|
|
withdrawalAmount: amountRaw,
|
|
walletTypeId: ledgerWalletType.id,
|
|
});
|
|
}
|
|
catch (referralErr) {
|
|
console.error('[referral] Withdrawal commission processing failed:', referralErr);
|
|
}
|
|
return {
|
|
transactionId: tx.id,
|
|
status: 'completed',
|
|
amount: amountRaw.toString(),
|
|
fee: feeRaw.toString(),
|
|
totalDebited: totalDebit.toString(),
|
|
};
|
|
}
|
|
catch (err) {
|
|
if (!blockchainTxId) {
|
|
await ledgerRepository.unlockBalance(account.id, totalDebit);
|
|
await withdrawalLockRepository.deleteByTransactionId(tx.id);
|
|
await transactionRepository.updateStatus(tx.id, 'failed');
|
|
await auditLogRepository.create({
|
|
userId,
|
|
action: 'withdrawal_failed',
|
|
resourceType: 'transaction',
|
|
resourceId: tx.id,
|
|
metadata: { error: String(err) },
|
|
});
|
|
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(userId);
|
|
}
|
|
if (err instanceof securityService_1.SecurityBlockedError)
|
|
throw err;
|
|
throw err;
|
|
}
|
|
}
|
|
//# sourceMappingURL=withdrawalService.js.map
|