games_app/backend/dist/services/withdrawalService.js

832 lines
37 KiB
JavaScript

"use strict";
/**
* On-chain withdrawal service (state machine v2).
*
* A valid request is always recorded as `pending` with `amount + fee` reserved on the user's
* unified USDT ledger (USDT_TRC20, 6 decimals), even when the platform hot wallet cannot pay
* right now. Payout runs separately: pending -> processing -> completed once the transaction
* is confirmed on-chain. Platform liquidity problems never surface to the user — the request
* simply stays pending until an admin (or the automatic attempt) processes it.
*/
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.broadcastApprovedWithdrawal = void 0;
exports.requestWithdrawal = requestWithdrawal;
exports.processWithdrawal = processWithdrawal;
exports.processApprovedWithdrawal = processApprovedWithdrawal;
exports.verifyBroadcastWithdrawal = verifyBroadcastWithdrawal;
exports.runWithdrawalAutoRetryCycle = runWithdrawalAutoRetryCycle;
exports.runWithdrawalMonitorCycle = runWithdrawalMonitorCycle;
exports.rejectWithdrawal = rejectWithdrawal;
exports.cancelWithdrawal = cancelWithdrawal;
exports.cancelWithdrawalFromApproval = cancelWithdrawalFromApproval;
exports.requeueWithdrawal = requeueWithdrawal;
const config_1 = require("../config");
const connection_1 = require("../db/connection");
const hdWallet_1 = require("./hdWallet");
const transactionRepository = __importStar(require("../repositories/transactionRepository"));
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 withdrawalRepository = __importStar(require("../repositories/withdrawalRepository"));
const fundOperationRequestRepository = __importStar(require("../repositories/fundOperationRequestRepository"));
const withdrawalFee_1 = require("../utils/withdrawalFee");
const securityService_1 = require("./securityService");
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");
const walletNotificationService = __importStar(require("./walletNotificationService"));
const withdrawalStateMachine_1 = require("./withdrawals/withdrawalStateMachine");
const withdrawalPayoutService_1 = require("./withdrawals/withdrawalPayoutService");
const SYSTEM_ACTOR = { actorType: 'system' };
/** Claimed rows with no signed payout after this long are considered interrupted. */
const STALE_CLAIM_MINUTES = 10;
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, amountRaw, feeRaw, settings, client) {
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, client);
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;
}
}
async function flagLargeWithdrawal(userId, railWalletType, amountRaw, amountUsd, settings) {
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));
}
function toResult(row, extra = {}) {
const total = BigInt(row.amount) + BigInt(row.fee || '0');
return {
transactionId: row.id,
status: row.status,
amount: row.amount,
fee: row.fee,
totalDebited: total.toString(),
blockchainTxId: row.status === 'completed' ? row.blockchain_tx_id : null,
...extra,
};
}
function rowNetwork(row) {
const n = String(row.metadata?.network ?? '');
return n === 'TRON' || n === 'BSC' ? n : null;
}
function rowRailCode(row) {
return String(row.metadata?.rail_wallet_type ?? '');
}
/**
* Records a withdrawal request: validates, reserves funds and returns status `pending`.
* Never fails because of platform hot-wallet liquidity.
*/
async function requestWithdrawal(userId, walletTypeCode, toAddress, amountRaw, totpCode, options = {}) {
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');
const destination = toAddress.trim();
assertPayoutAddress(network, destination);
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 amountUsd = (0, withdrawalLimits_1.rawAmountToUsdApprox)(walletCapabilities_1.USDT_TRC20_CODE, amountRaw, usdtUnits_1.LEDGER_USDT_DECIMALS);
const requiresApproval = amountUsd >= settings.large_withdrawal_threshold_usd;
const { row, duplicate } = await withdrawalRepository.createWithdrawalRequest({
userId,
walletTypeId: ledgerWalletType.id,
amountRaw,
feeRaw,
toAddress: destination,
requiredConfirmations: network === 'TRON' ? config_1.config.blockchain.tron.confirmations : config_1.config.blockchain.bsc.confirmations,
metadata: { rail_wallet_type: walletTypeCode, network },
pendingReason: requiresApproval ? 'awaiting_approval' : 'queued',
idempotencyKey: options.idempotencyKey?.trim() || null,
insufficientMessage: feeRaw > 0n ? 'Insufficient balance (withdrawal amount + network fee)' : 'Insufficient balance',
beforeReserve: (client) => assertWithdrawalWithinLimits(userId, amountRaw, feeRaw, settings, client),
});
if (duplicate)
return toResult(row, { duplicate: true });
await auditLogRepository.create({
userId,
action: 'withdrawal_requested',
resourceType: 'transaction',
resourceId: row.id,
metadata: {
amount: amountRaw.toString(),
fee: feeRaw.toString(),
toAddress: destination,
walletType: walletTypeCode,
network,
requiresApproval,
},
});
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(userId);
void walletNotificationService.notifyWithdrawalSubmitted(userId, {
amountRaw,
feeRaw,
toAddress: destination,
network,
transactionId: row.id,
pendingApproval: requiresApproval,
});
let fundRequestId;
if (requiresApproval) {
await flagLargeWithdrawal(userId, railWalletType, amountRaw, amountUsd, settings);
const hotWallet = await hotWalletRepository.getActiveHotWallet(railWalletType.id);
try {
const { createFundRequest } = await Promise.resolve().then(() => __importStar(require('./fundApprovalService')));
const fundReq = await createFundRequest({
operationType: 'user_withdrawal',
payload: {
transactionId: row.id,
userId,
amountRaw: amountRaw.toString(),
feeRaw: feeRaw.toString(),
walletTypeId: railWalletType.id,
walletCode: walletTypeCode,
assetCode: walletTypeCode,
network,
fromAddress: hotWallet?.address ?? null,
toAddress: destination,
},
requestedBy: userId,
skipRequestPermission: true,
});
fundRequestId = fundReq.id;
await withdrawalRepository.patchPendingDetails(row.id, {
metadata: { fund_request_id: fundReq.id },
});
}
catch (e) {
// The request stays pending (awaiting approval) and remains visible to admins.
console.error('[withdrawal] approval request creation failed:', e);
await auditLogRepository.create({
userId,
action: 'withdrawal_approval_request_failed',
resourceType: 'transaction',
resourceId: row.id,
metadata: { error: e instanceof Error ? e.message : String(e) },
});
}
}
else if (options.autoProcess !== false) {
scheduleProcessing(row.id);
}
const fresh = (await withdrawalRepository.findWithdrawal(row.id)) ?? row;
return toResult(fresh, fundRequestId ? { fundRequestId } : {});
}
/** Starts an automatic payout attempt without blocking the HTTP response. */
function scheduleProcessing(transactionId) {
setImmediate(() => {
processWithdrawal(transactionId, SYSTEM_ACTOR).catch((e) => {
if (e instanceof withdrawalStateMachine_1.WithdrawalStateError)
return;
console.error('[withdrawal] automatic processing error:', e);
});
});
}
const PAYOUT_LOCK_NS = 872364302;
/** Serializes sign + broadcast per network (nonce safety, in-flight liquidity accounting). */
async function withPayoutLock(network, fn) {
const client = await (0, connection_1.getClient)();
try {
await client.query('SELECT pg_advisory_lock($1, $2)', [PAYOUT_LOCK_NS, network === 'TRON' ? 1 : 2]);
try {
return await fn();
}
finally {
await client
.query('SELECT pg_advisory_unlock($1, $2)', [PAYOUT_LOCK_NS, network === 'TRON' ? 1 : 2])
.catch(() => undefined);
}
}
finally {
client.release();
}
}
function stateErrorMessage(code, status) {
switch (code) {
case 'WITHDRAWAL_NOT_FOUND':
return 'Withdrawal not found';
case 'WITHDRAWAL_AWAITING_APPROVAL':
return 'This withdrawal is waiting for the large-withdrawal approval quorum (see Approvals).';
case 'WITHDRAWAL_ALREADY_BROADCAST':
return 'A payout transaction already exists for this withdrawal; it is being verified on-chain.';
case 'WITHDRAWAL_LEGACY_READ_ONLY':
return 'Legacy withdrawal record: manual review required.';
default:
return `Withdrawal cannot be changed from its current status (${status ?? 'unknown'}).`;
}
}
function throwStateError(res) {
throw new withdrawalStateMachine_1.WithdrawalStateError(res.code, stateErrorMessage(res.code, res.status));
}
async function moveToPending(row, reason, actor, detail, discardUnsentHash = false) {
const res = await withdrawalRepository.releaseToPending(row.id, {
reason,
lastError: detail ?? null,
actor,
discardUnsentHash,
});
if (res.ok) {
await auditLogRepository.create({
userId: actor.actorUserId ?? null,
action: 'withdrawal_returned_to_pending',
resourceType: 'transaction',
resourceId: row.id,
metadata: { reason, detail: detail ?? null },
});
}
return { transactionId: row.id, status: 'pending', pendingReason: reason, message: detail };
}
async function moveToFailed(row, error, actor) {
const res = await withdrawalRepository.failProcessing(row.id, { error, actor });
if (res.ok) {
await auditLogRepository.create({
userId: actor.actorUserId ?? null,
action: 'withdrawal_failed',
resourceType: 'transaction',
resourceId: row.id,
metadata: { error },
});
void walletNotificationService.notifyWithdrawalFailed(row.user_id, {
amountRaw: BigInt(row.amount),
feeRaw: BigInt(row.fee || '0'),
toAddress: row.to_address ?? undefined,
transactionId: row.id,
});
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(row.user_id);
}
return { transactionId: row.id, status: 'failed', message: error };
}
/**
* Attempts the payout of a pending/failed request: pending|failed -> processing, then either
* broadcast (stays processing until confirmed), back to pending (liquidity), or failed.
* Throws WithdrawalStateError only when the request cannot be processed from its status.
*/
async function processWithdrawal(transactionId, actor, opts = {}) {
const claim = await withdrawalRepository.claimForProcessing(transactionId, actor, opts);
if (!claim.ok)
throwStateError(claim);
const row = claim.row;
await auditLogRepository.create({
userId: actor.actorUserId ?? null,
action: 'withdrawal_processing_started',
resourceType: 'transaction',
resourceId: row.id,
metadata: { attempt: row.processing_attempts, from: claim.fromStatus, actor: actor.actorType },
});
if (claim.fromStatus === 'failed' || row.processing_attempts === 1) {
void walletNotificationService.notifyWithdrawalProcessing(row.user_id, { transactionId: row.id });
}
try {
try {
await (0, securityService_1.assertUserCanWithdraw)(row.user_id);
}
catch (e) {
if (e instanceof securityService_1.SecurityBlockedError) {
return moveToPending(row, 'account_on_hold', actor, e.message);
}
throw e;
}
const network = rowNetwork(row);
const railWalletType = await walletRepository.getWalletTypeByCode(rowRailCode(row));
if (!network || !railWalletType) {
return moveToFailed(row, 'Unknown withdrawal network', actor);
}
const hotWallet = await hotWalletRepository.getActiveHotWallet(railWalletType.id);
if (!hotWallet) {
return moveToPending(row, 'hot_wallet_unavailable', actor, `No active hot wallet for ${network}`);
}
return await withPayoutLock(network, () => executePayout(row, actor, network, railWalletType, hotWallet));
}
catch (e) {
const msg = e instanceof Error ? e.message : String(e);
const current = await withdrawalRepository.findWithdrawal(row.id);
if (current?.status === 'processing' && current.blockchain_tx_id) {
// A signed payout may be on the network: never fail blindly, the monitor verifies it.
console.error(`[withdrawal] ${row.id} error after signing, left for on-chain verification:`, msg);
return { transactionId: row.id, status: 'processing', message: msg };
}
if (current?.status === 'processing')
return moveToFailed(current, msg, actor);
return { transactionId: row.id, status: current?.status ?? 'unknown', message: msg };
}
}
async function executePayout(row, actor, network, railWalletType, hotWallet) {
const amountRaw = BigInt(row.amount);
const usdtContract = railWalletType.contract_address || '';
const inFlightRaw = await withdrawalRepository.sumInFlightPayouts(network, row.id);
const balances = await (0, hotLiquidityService_1.readHotBalances)({ network, hotAddress: hotWallet.address, usdtContract });
const verdict = (0, hotLiquidityService_1.evaluateHotLiquidity)({
network,
usdtBalanceRaw: balances.usdtBalanceRaw,
nativeBalanceRaw: balances.nativeBalanceRaw,
ledgerAmountRaw: amountRaw + inFlightRaw,
});
if (!verdict.ok) {
const detail = `Hot wallet ${verdict.reason === 'usdt' ? 'USDT' : 'gas'} insufficient on ${network} (needed ${verdict.needed}, available ${verdict.available}, in-flight ${inFlightRaw})`;
return moveToPending(row, verdict.reason === 'usdt' ? 'awaiting_liquidity' : 'awaiting_gas', actor, detail);
}
let signed;
try {
signed = await (0, withdrawalPayoutService_1.signPayout)({
network,
privateKey: (0, hdWallet_1.decryptPrivateKey)(hotWallet.encrypted_private_key),
usdtContract,
toAddress: row.to_address || '',
ledgerAmountRaw: amountRaw,
});
}
catch (e) {
if (e instanceof withdrawalPayoutService_1.PayoutError && (e.kind === 'liquidity_usdt' || e.kind === 'liquidity_gas')) {
return moveToPending(row, e.kind === 'liquidity_usdt' ? 'awaiting_liquidity' : 'awaiting_gas', actor, e.message);
}
return moveToFailed(row, `Could not prepare payout: ${e instanceof Error ? e.message : String(e)}`, actor);
}
const recorded = await withdrawalRepository.recordSignedPayout(row.id, {
txHash: signed.txHash,
signedPayload: signed.payload,
expiresAt: signed.expiresAt,
fromAddress: signed.fromAddress,
});
if (!recorded) {
return moveToFailed(row, 'Withdrawal state changed before broadcast', actor);
}
const outcome = await (0, withdrawalPayoutService_1.broadcastPayout)(signed);
if (outcome.kind === 'accepted') {
await withdrawalRepository.markBroadcast(row.id, { stage: 'broadcast' });
await auditLogRepository.create({
userId: actor.actorUserId ?? null,
action: 'withdrawal_broadcast',
resourceType: 'transaction',
resourceId: row.id,
metadata: { txHash: signed.txHash, network },
});
return { transactionId: row.id, status: 'processing', blockchainTxId: signed.txHash };
}
if (outcome.kind === 'uncertain') {
await withdrawalRepository.markBroadcast(row.id, {
stage: 'broadcast_uncertain',
lastError: outcome.message,
});
return {
transactionId: row.id,
status: 'processing',
blockchainTxId: signed.txHash,
message: 'Broadcast response lost; the payout is being verified on-chain.',
};
}
if (outcome.failure === 'liquidity_usdt' || outcome.failure === 'liquidity_gas') {
return moveToPending(row, outcome.failure === 'liquidity_usdt' ? 'awaiting_liquidity' : 'awaiting_gas', actor, outcome.message, true);
}
return moveToFailed(row, `Network refused payout: ${outcome.message}`, actor);
}
/** Called by the approval workflow once the large-withdrawal quorum is reached. */
async function processApprovedWithdrawal(transactionId, approvedBy) {
const result = await processWithdrawal(transactionId, { actorType: 'admin', actorUserId: approvedBy }, { approvalGranted: true });
return { ...result };
}
/** @deprecated name kept for the approval workflow; payout is now asynchronous. */
exports.broadcastApprovedWithdrawal = processApprovedWithdrawal;
async function onCompleted(row) {
const network = rowNetwork(row);
await auditLogRepository.create({
userId: row.user_id,
action: 'withdrawal_completed',
resourceType: 'transaction',
resourceId: row.id,
metadata: {
amount: row.amount,
fee: row.fee,
toAddress: row.to_address,
blockchainTxId: row.blockchain_tx_id,
network,
confirmations: row.confirmations,
},
});
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(row.user_id);
void walletNotificationService.notifyWithdrawalCompleted(row.user_id, {
amountRaw: BigInt(row.amount),
feeRaw: BigInt(row.fee || '0'),
toAddress: row.to_address || '',
network: network ?? undefined,
transactionId: row.id,
blockchainTxId: row.blockchain_tx_id,
});
try {
await referralService.processWithdrawalReferralCommissions({
userId: row.user_id,
withdrawalTransactionId: row.id,
withdrawalAmount: BigInt(row.amount),
walletTypeId: row.wallet_type_id,
});
}
catch (referralErr) {
console.error('[referral] Withdrawal commission processing failed:', referralErr);
}
}
/** Verifies one broadcast payout on-chain and advances its status when the result is known. */
async function verifyBroadcastWithdrawal(row, nowMs = Date.now()) {
const network = rowNetwork(row);
const hash = row.blockchain_tx_id;
if (!network || !hash)
return 'skipped';
const status = await (0, withdrawalPayoutService_1.getPayoutStatus)(network, hash);
if (status.kind === 'mined') {
if (!status.success) {
await moveToFailed(row, `Payout transaction failed on-chain${status.message ? `: ${status.message}` : ''}`, SYSTEM_ACTOR);
void (0, securityService_1.raiseAlert)({
userId: row.user_id,
severity: 'high',
alertType: 'withdrawal_payout_reverted',
title: 'Withdrawal payout reverted on-chain',
details: `transaction=${row.id}, hash=${hash}, network=${network}`,
metadata: { transactionId: row.id, txHash: hash, network },
}).catch(() => undefined);
return 'failed';
}
const required = row.required_confirmations ?? 1;
if (status.confirmations >= required) {
const done = await withdrawalRepository.finalizeCompleted(row.id, {
confirmations: status.confirmations,
});
if (done.ok)
await onCompleted(done.row);
return done.ok ? 'completed' : 'skipped';
}
await withdrawalRepository.updateConfirmations(row.id, status.confirmations);
return 'confirming';
}
if (status.kind === 'pending')
return 'pending';
const nonceConsumed = network === 'BSC' && row.signed_payload && row.from_address
? await (0, withdrawalPayoutService_1.isBscNonceConsumed)(row.from_address, row.signed_payload)
: undefined;
const decision = (0, withdrawalPayoutService_1.decideMissingPayout)({
network,
nowMs,
broadcastAtMs: row.broadcast_at ? new Date(row.broadcast_at).getTime() : null,
expiresAtMs: row.signed_expires_at ? new Date(row.signed_expires_at).getTime() : null,
nonceConsumed,
});
if (decision === 'dropped') {
await moveToFailed(row, 'Payout was never included on-chain and has expired', SYSTEM_ACTOR);
return 'failed';
}
if (decision === 'rebroadcast' && row.signed_payload) {
try {
await (0, withdrawalPayoutService_1.rebroadcastPayout)(network, row.signed_payload);
await withdrawalRepository.markBroadcast(row.id, { stage: 'broadcast' });
}
catch (e) {
console.warn(`[withdrawal] rebroadcast ${row.id} failed:`, e instanceof Error ? e.message : e);
}
return 'rebroadcast';
}
return 'waiting';
}
/** Pending reasons that clear on their own once the hot wallet is replenished. */
const AUTO_RETRY_REASONS = [
'awaiting_liquidity',
'awaiting_gas',
'hot_wallet_unavailable',
];
const AUTO_RETRY_BATCH = 20;
/**
* Automatic retry pass (only when enabled in settings). A request is claimed only when the
* hot wallet can pay it right now (USDT + gas, minus payouts already in flight), so an
* unfunded wallet produces no status churn.
*/
async function runWithdrawalAutoRetryCycle() {
const settings = await settingsRepository.getSettings();
if (!settings.withdrawal_auto_retry_enabled || !settings.allow_withdrawals) {
return { attempted: 0, skipped: 0 };
}
const rows = await withdrawalRepository.listAutoRetryCandidates(AUTO_RETRY_REASONS, AUTO_RETRY_BATCH);
const balancesByNetwork = new Map();
let attempted = 0;
let skipped = 0;
for (const row of rows) {
const network = rowNetwork(row);
const railWalletType = await walletRepository.getWalletTypeByCode(rowRailCode(row));
const hotWallet = railWalletType
? await hotWalletRepository.getActiveHotWallet(railWalletType.id)
: null;
if (!network || !railWalletType || !hotWallet) {
skipped++;
continue;
}
if (!balancesByNetwork.has(network)) {
const balances = await (0, hotLiquidityService_1.readHotBalances)({
network,
hotAddress: hotWallet.address,
usdtContract: railWalletType.contract_address || '',
}).catch((e) => {
console.warn(`[withdrawal] auto-retry balance read failed (${network}):`, e instanceof Error ? e.message : e);
return null;
});
balancesByNetwork.set(network, balances);
}
const balances = balancesByNetwork.get(network);
if (!balances) {
skipped++;
continue;
}
const inFlightRaw = await withdrawalRepository.sumInFlightPayouts(network, row.id);
const verdict = (0, hotLiquidityService_1.evaluateHotLiquidity)({
network,
usdtBalanceRaw: balances.usdtBalanceRaw,
nativeBalanceRaw: balances.nativeBalanceRaw,
ledgerAmountRaw: BigInt(row.amount) + inFlightRaw,
});
if (!verdict.ok) {
skipped++;
continue;
}
try {
attempted++;
await processWithdrawal(row.id, SYSTEM_ACTOR);
}
catch (e) {
if (!(e instanceof withdrawalStateMachine_1.WithdrawalStateError)) {
console.error(`[withdrawal] auto-retry ${row.id} failed:`, e);
}
}
}
return { attempted, skipped };
}
let lastAutoRetryAtMs = 0;
async function maybeRunAutoRetry(nowMs) {
const settings = await settingsRepository.getSettings();
if (!settings.withdrawal_auto_retry_enabled)
return;
const intervalMs = Math.max(1, settings.withdrawal_auto_retry_interval_minutes || 10) * 60000;
if (nowMs - lastAutoRetryAtMs < intervalMs)
return;
lastAutoRetryAtMs = nowMs;
const r = await runWithdrawalAutoRetryCycle();
if (r.attempted > 0)
console.log(`[withdrawal] auto-retry started ${r.attempted} payout(s)`);
}
/** One pass of the confirmation monitor (also recovers interrupted claims and auto-retries). */
async function runWithdrawalMonitorCycle() {
let completed = 0;
const rows = await withdrawalRepository.listAwaitingChainResult(50);
for (const row of rows) {
try {
const outcome = await verifyBroadcastWithdrawal(row);
if (outcome === 'completed')
completed++;
}
catch (e) {
console.warn(`[withdrawal] verify ${row.id} failed:`, e instanceof Error ? e.message : e);
}
}
const stale = await withdrawalRepository.listStaleClaims(STALE_CLAIM_MINUTES);
for (const row of stale) {
await moveToPending(row, 'processing_interrupted', SYSTEM_ACTOR, 'Processing was interrupted before signing');
}
try {
await maybeRunAutoRetry(Date.now());
}
catch (e) {
console.error('[withdrawal] auto-retry pass failed:', e);
}
return { checked: rows.length, completed };
}
async function resolveLinkedFundRequest(row) {
const fromMeta = row.metadata?.fund_request_id;
if (typeof fromMeta === 'string' && fromMeta)
return fromMeta;
return withdrawalRepository.findFundRequestIdForWithdrawal(row.id);
}
/**
* Closes the approval request of a large withdrawal before it is refunded.
* Refuses when the quorum was already reached (the payout is underway).
*/
async function closeApprovalRequest(row, mode) {
if (row.pending_reason !== 'awaiting_approval')
return;
const fundRequestId = await resolveLinkedFundRequest(row);
if (!fundRequestId)
return;
const closed = mode.kind === 'reject'
? await fundOperationRequestRepository.markRejected(fundRequestId, mode.actorId, mode.reason)
: await fundOperationRequestRepository.markCancelled(fundRequestId);
if (closed)
return;
const fund = await fundOperationRequestRepository.findById(fundRequestId);
if (fund && (fund.status === 'approved' || fund.status === 'processing')) {
throw new withdrawalStateMachine_1.WithdrawalStateError('WITHDRAWAL_INVALID_TRANSITION', 'The approval quorum was already reached; the withdrawal is being processed.');
}
}
/** Admin refusal (pending|failed -> rejected) with a full, single refund. */
async function rejectWithdrawal(transactionId, input) {
const reason = input.reason.trim();
if (!reason)
throw new Error('Rejection reason is required');
const row = await withdrawalRepository.findWithdrawal(transactionId);
if (!row)
throw new withdrawalStateMachine_1.WithdrawalStateError('WITHDRAWAL_NOT_FOUND', 'Withdrawal not found');
if (input.source !== 'approval') {
await closeApprovalRequest(row, { kind: 'reject', actorId: input.actorId, reason });
}
const res = await withdrawalRepository.refundWithdrawal(transactionId, {
toStatus: 'rejected',
actor: { actorType: 'admin', actorUserId: input.actorId },
reason,
});
if (!res.ok)
throwStateError(res);
await auditLogRepository.create({
userId: input.actorId,
action: 'withdrawal_rejected',
resourceType: 'transaction',
resourceId: transactionId,
metadata: {
reason,
source: input.source ?? 'admin',
refundedAmount: (BigInt(res.row.amount) + BigInt(res.row.fee || '0')).toString(),
ownerUserId: res.row.user_id,
},
});
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(res.row.user_id);
void walletNotificationService.notifyWithdrawalRejected(res.row.user_id, {
amountRaw: BigInt(res.row.amount),
feeRaw: BigInt(res.row.fee || '0'),
transactionId,
});
return res.row;
}
/** User cancellation of a request that is still pending (pending -> cancelled, refunded). */
async function cancelWithdrawal(transactionId, input) {
const row = await withdrawalRepository.findWithdrawal(transactionId);
if (!row || row.user_id !== input.userId) {
throw new withdrawalStateMachine_1.WithdrawalStateError('WITHDRAWAL_NOT_FOUND', 'Withdrawal not found');
}
if (row.status !== 'pending') {
throw new withdrawalStateMachine_1.WithdrawalStateError('WITHDRAWAL_INVALID_TRANSITION', 'Only a withdrawal that has not started processing can be cancelled.');
}
if (input.source !== 'approval')
await closeApprovalRequest(row, { kind: 'cancel' });
const actorType = input.actorType ?? 'user';
const res = await withdrawalRepository.refundWithdrawal(transactionId, {
toStatus: 'cancelled',
actor: { actorType, actorUserId: input.actorId ?? input.userId },
reason: actorType === 'user' ? 'cancelled_by_user' : 'cancelled',
ownerUserId: input.userId,
});
if (!res.ok)
throwStateError(res);
await auditLogRepository.create({
userId: input.actorId ?? input.userId,
action: 'withdrawal_cancelled',
resourceType: 'transaction',
resourceId: transactionId,
metadata: {
refundedAmount: (BigInt(res.row.amount) + BigInt(res.row.fee || '0')).toString(),
source: input.source ?? 'user',
},
});
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(res.row.user_id);
void walletNotificationService.notifyWithdrawalCancelled(res.row.user_id, {
amountRaw: BigInt(res.row.amount),
feeRaw: BigInt(res.row.fee || '0'),
transactionId,
});
return res.row;
}
/** Approval workflow cancelled by the requester / super admin. */
async function cancelWithdrawalFromApproval(transactionId, actorId) {
const row = await withdrawalRepository.findWithdrawal(transactionId);
if (!row || row.status !== 'pending')
return;
await cancelWithdrawal(transactionId, {
userId: row.user_id,
actorType: actorId === row.user_id ? 'user' : 'admin',
actorId,
source: 'approval',
});
}
/** Admin: failed -> pending (e.g. before a later retry). */
async function requeueWithdrawal(transactionId, actorId) {
const row = await withdrawalRepository.findWithdrawal(transactionId);
if (!row)
throw new withdrawalStateMachine_1.WithdrawalStateError('WITHDRAWAL_NOT_FOUND', 'Withdrawal not found');
if (row.status !== 'failed') {
throw new withdrawalStateMachine_1.WithdrawalStateError('WITHDRAWAL_INVALID_TRANSITION', 'Only a failed withdrawal can be put back in the queue.');
}
const res = await withdrawalRepository.releaseToPending(transactionId, {
reason: 'requeued_by_admin',
actor: { actorType: 'admin', actorUserId: actorId },
});
if (!res.ok)
throwStateError(res);
await auditLogRepository.create({
userId: actorId,
action: 'withdrawal_requeued',
resourceType: 'transaction',
resourceId: transactionId,
});
return res.row;
}
//# sourceMappingURL=withdrawalService.js.map