318 lines
14 KiB
JavaScript
318 lines
14 KiB
JavaScript
"use strict";
|
||
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.computeWeightedPoolContribution = computeWeightedPoolContribution;
|
||
exports.computeMultiCandlePoolContribution = computeMultiCandlePoolContribution;
|
||
exports.computeMultiCandleWinPayout = computeMultiCandleWinPayout;
|
||
exports.resolveMaturityOutcomeMode = resolveMaturityOutcomeMode;
|
||
exports.resolveGameOutcomeCreditKind = resolveGameOutcomeCreditKind;
|
||
exports.mapMultiLevel = mapMultiLevel;
|
||
exports.mapMultiLevelForPlayer = mapMultiLevelForPlayer;
|
||
exports.mapMultiBet = mapMultiBet;
|
||
exports.buildMaturityPools = buildMaturityPools;
|
||
exports.processMultiBetsAtMaturity = processMultiBetsAtMaturity;
|
||
const transactionRepository = __importStar(require("../repositories/transactionRepository"));
|
||
const repo = __importStar(require("../repositories/candlePredictRepository"));
|
||
const ledgerRepository = __importStar(require("../repositories/ledgerRepository"));
|
||
const userAdminStatsService_1 = require("./userAdminStatsService");
|
||
const predictionAuditService = __importStar(require("./predictionAuditService"));
|
||
const referralService_1 = require("./referralService");
|
||
const config_1 = require("../config");
|
||
const pubsub_1 = require("../realtime/redis/pubsub");
|
||
const stateVersions_1 = require("../realtime/redis/stateVersions");
|
||
const STAKE_DECIMALS = 6;
|
||
function stakeToRaw(stakeDisplay) {
|
||
return BigInt(Math.round(stakeDisplay * 10 ** STAKE_DECIMALS));
|
||
}
|
||
function rawToStake(raw) {
|
||
return Number(raw) / 10 ** STAKE_DECIMALS;
|
||
}
|
||
function parseStakeAccountKind(value) {
|
||
if (value === 'bonus')
|
||
return 'bonus';
|
||
if (value === 'test')
|
||
return 'test';
|
||
return 'main';
|
||
}
|
||
/** Referral prediction commissions only on terminal win/loss — never on neutral refund. */
|
||
function queuePredictionReferralCommission(bet, betOutcome) {
|
||
void (0, referralService_1.processPredictionReferralCommissions)({
|
||
betId: bet.id,
|
||
referredUserId: bet.user_id,
|
||
stakeRaw: BigInt(bet.stake_raw),
|
||
stakeAccountKind: parseStakeAccountKind(bet.stake_account_kind),
|
||
walletTypeId: bet.wallet_type_id,
|
||
betOutcome,
|
||
}).catch((e) => console.error('[referral] prediction commission failed:', e));
|
||
}
|
||
async function creditGameOutcome(bet, amount, entryType) {
|
||
const stakeKind = parseStakeAccountKind(bet.stake_account_kind);
|
||
const creditKind = resolveGameOutcomeCreditKind(stakeKind, entryType);
|
||
const account = await ledgerRepository.getOrCreateAccount(bet.user_id, bet.wallet_type_id, creditKind);
|
||
await ledgerRepository.credit(account.id, amount, entryType, 'candle_predict_bet', bet.id);
|
||
}
|
||
function parseSequenceDirections(value) {
|
||
if (!Array.isArray(value))
|
||
return [];
|
||
return value.filter((d) => d === 'short' || d === 'long');
|
||
}
|
||
/**
|
||
* Effective pool weight for outcome resolution (single, auto, multi).
|
||
* Uses stake × admin-configured pool multiplier.
|
||
*/
|
||
function computeWeightedPoolContribution(stakeDisplay, poolMultiplier) {
|
||
return stakeDisplay * poolMultiplier;
|
||
}
|
||
/**
|
||
* Effective stake added to Long/Short pools at the final multi-candle step.
|
||
*/
|
||
function computeMultiCandlePoolContribution(stakeDisplay, poolMultiplier) {
|
||
return computeWeightedPoolContribution(stakeDisplay, poolMultiplier);
|
||
}
|
||
/**
|
||
* Win payout when the full multi-candle sequence is correct.
|
||
* Uses the admin-configured payout multiplier only (independent from pool weight).
|
||
*/
|
||
function computeMultiCandleWinPayout(stakeDisplay, payoutMultiplier) {
|
||
return stakeDisplay * payoutMultiplier;
|
||
}
|
||
/**
|
||
* Whether candle outcome at this maturity is driven by real-money stake pools.
|
||
* Multi-candle bets in progress on intermediate steps never use pool mode — only
|
||
* singles maturing here or multi bets on their final sequence step (pool weight).
|
||
*/
|
||
function resolveMaturityOutcomeMode(params) {
|
||
const hasRealMoneyPool = params.realMoneySinglePending ||
|
||
params.multiFinalPoolShort > 0 ||
|
||
params.multiFinalPoolLong > 0;
|
||
return hasRealMoneyPool ? 'pool' : 'auto';
|
||
}
|
||
/** Ledger account credited on win/refund; bonus payouts go to main, test stays on test. */
|
||
function resolveGameOutcomeCreditKind(stakeAccountKind, entryType) {
|
||
if (entryType === 'game_payout' && stakeAccountKind === 'bonus') {
|
||
return 'main';
|
||
}
|
||
return stakeAccountKind;
|
||
}
|
||
async function notifyMultiBetUpdate(userId, intervalMinutes, userMultiBet) {
|
||
if (!config_1.config.redis.enabled)
|
||
return;
|
||
const betVersion = await (0, stateVersions_1.bumpUserBetVersionSafe)(userId, intervalMinutes);
|
||
await (0, pubsub_1.publishUserEvent)(userId, {
|
||
type: 'multi.updated',
|
||
payload: {
|
||
intervalMinutes,
|
||
userMultiBet: userMultiBet,
|
||
...(betVersion != null ? { versions: { bet: betVersion } } : {}),
|
||
},
|
||
});
|
||
}
|
||
function mapMultiLevel(row) {
|
||
return {
|
||
level: row.level,
|
||
candleCount: row.level,
|
||
enabled: row.enabled,
|
||
/** Admin-configurable multiplier for win payout when the full sequence is correct. */
|
||
payoutMultiplier: Number(row.payout_multiplier),
|
||
/** Admin-configurable multiplier for pool integration at the final candle. */
|
||
poolMultiplier: Number(row.pool_multiplier),
|
||
sortOrder: row.sort_order,
|
||
};
|
||
}
|
||
function mapMultiLevelForPlayer(row) {
|
||
const { poolMultiplier: _pool, ...player } = mapMultiLevel(row);
|
||
return player;
|
||
}
|
||
function mapMultiBet(row) {
|
||
const anchorMs = row.anchor_candle_open_ms != null && row.anchor_candle_open_ms !== ''
|
||
? Number(row.anchor_candle_open_ms)
|
||
: null;
|
||
const intervalMs = row.interval_minutes * 60 * 1000;
|
||
const step = row.sequence_step ?? 0;
|
||
const currentCandleOpenMs = anchorMs != null ? anchorMs + step * intervalMs : null;
|
||
return {
|
||
id: row.id,
|
||
roundId: row.round_id,
|
||
predictionMode: 'multi_candle',
|
||
direction: row.direction,
|
||
stakeDisplay: Number(row.stake_display),
|
||
status: row.status,
|
||
payoutDisplay: rawToStake(BigInt(row.payout_raw)),
|
||
intervalMinutes: row.interval_minutes,
|
||
level: row.multi_level ?? 0,
|
||
sequenceDirections: parseSequenceDirections(row.sequence_directions),
|
||
sequenceStep: step,
|
||
stakeAccountKind: parseStakeAccountKind(row.stake_account_kind),
|
||
anchorCandleOpenMs: anchorMs,
|
||
currentCandleOpenMs,
|
||
createdAt: row.created_at.toISOString(),
|
||
};
|
||
}
|
||
/** Single pending pools plus real-money multi contributions at final sequence step. */
|
||
async function buildMaturityPools(candleOpenMs) {
|
||
const [single, multi] = await Promise.all([
|
||
repo.getGlobalPoolTotalsForMaturity(candleOpenMs),
|
||
repo.getMultiCandlePoolContributions(candleOpenMs),
|
||
]);
|
||
return {
|
||
shortPool: single.shortPool + multi.shortPool,
|
||
longPool: single.longPool + multi.longPool,
|
||
};
|
||
}
|
||
async function processMultiBetsAtMaturity(candleOpenMs, outcomeForInterval, payoutMultiplierMap) {
|
||
const bets = await repo.listMultiBetsForValidationAtOpenMs(candleOpenMs);
|
||
if (!bets.length)
|
||
return 0n;
|
||
const resolveOutcome = typeof outcomeForInterval === 'function'
|
||
? outcomeForInterval
|
||
: (_intervalMinutes) => outcomeForInterval;
|
||
let housePnlRaw = 0n;
|
||
for (const bet of bets) {
|
||
const outcome = resolveOutcome(bet.interval_minutes);
|
||
const sequence = parseSequenceDirections(bet.sequence_directions);
|
||
const level = bet.multi_level ?? sequence.length;
|
||
const step = bet.sequence_step ?? 0;
|
||
const expected = sequence[step];
|
||
const stakeRaw = BigInt(bet.stake_raw);
|
||
const countInDaily = bet.stake_account_kind === 'main' ||
|
||
bet.stake_account_kind === 'bonus' ||
|
||
bet.stake_account_kind == null;
|
||
if (outcome.type === 'neutral') {
|
||
await creditGameOutcome(bet, stakeRaw, 'game_refund');
|
||
await repo.updateBetOutcome(bet.id, 'refunded', stakeRaw);
|
||
void predictionAuditService.logPredictionBetSettled({
|
||
userId: bet.user_id,
|
||
betId: bet.id,
|
||
candleOpenMs,
|
||
status: 'refunded',
|
||
direction: expected,
|
||
outcomeType: outcome.type,
|
||
stakeRaw: bet.stake_raw,
|
||
payoutRaw: bet.stake_raw,
|
||
predictionMode: 'multi_candle',
|
||
intervalMinutes: bet.interval_minutes,
|
||
});
|
||
await transactionRepository.create({
|
||
userId: bet.user_id,
|
||
walletTypeId: bet.wallet_type_id,
|
||
type: 'game_refund',
|
||
amount: stakeRaw,
|
||
status: 'completed',
|
||
metadata: {
|
||
bet_id: bet.id,
|
||
round_id: bet.round_id,
|
||
candle_open_ms: candleOpenMs,
|
||
outcome: 'neutral',
|
||
prediction_mode: 'multi_candle',
|
||
stake_account_kind: parseStakeAccountKind(bet.stake_account_kind),
|
||
},
|
||
});
|
||
await transactionRepository.mergeGameStakeBetStatus(bet.id, 'refunded');
|
||
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(bet.user_id);
|
||
await notifyMultiBetUpdate(bet.user_id, bet.interval_minutes, null);
|
||
continue;
|
||
}
|
||
const actual = outcome.winner;
|
||
if (!expected || actual !== expected) {
|
||
await repo.updateBetOutcome(bet.id, 'lost', 0n);
|
||
await transactionRepository.mergeGameStakeBetStatus(bet.id, 'lost');
|
||
if (countInDaily)
|
||
housePnlRaw += stakeRaw;
|
||
void predictionAuditService.logPredictionBetSettled({
|
||
userId: bet.user_id,
|
||
betId: bet.id,
|
||
candleOpenMs,
|
||
status: 'lost',
|
||
direction: expected,
|
||
outcomeType: outcome.type,
|
||
stakeRaw: bet.stake_raw,
|
||
payoutRaw: '0',
|
||
predictionMode: 'multi_candle',
|
||
intervalMinutes: bet.interval_minutes,
|
||
});
|
||
queuePredictionReferralCommission(bet, 'lost');
|
||
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(bet.user_id);
|
||
await notifyMultiBetUpdate(bet.user_id, bet.interval_minutes, null);
|
||
continue;
|
||
}
|
||
const isFinalStep = step >= level - 1;
|
||
if (!isFinalStep) {
|
||
await repo.updateBetSequenceStep(bet.id, step + 1);
|
||
await notifyMultiBetUpdate(bet.user_id, bet.interval_minutes, mapMultiBet({ ...bet, sequence_step: step + 1 }));
|
||
continue;
|
||
}
|
||
const payoutMultiplier = payoutMultiplierMap.get(level) ?? 1;
|
||
const payoutRaw = stakeToRaw(computeMultiCandleWinPayout(Number(bet.stake_display), payoutMultiplier));
|
||
await creditGameOutcome(bet, payoutRaw, 'game_payout');
|
||
await repo.updateBetOutcome(bet.id, 'won', payoutRaw);
|
||
if (countInDaily)
|
||
housePnlRaw += stakeRaw - payoutRaw;
|
||
void predictionAuditService.logPredictionBetSettled({
|
||
userId: bet.user_id,
|
||
betId: bet.id,
|
||
candleOpenMs,
|
||
status: 'won',
|
||
direction: expected,
|
||
outcomeType: outcome.type,
|
||
stakeRaw: bet.stake_raw,
|
||
payoutRaw: payoutRaw.toString(),
|
||
predictionMode: 'multi_candle',
|
||
intervalMinutes: bet.interval_minutes,
|
||
});
|
||
await transactionRepository.create({
|
||
userId: bet.user_id,
|
||
walletTypeId: bet.wallet_type_id,
|
||
type: 'game_payout',
|
||
amount: payoutRaw,
|
||
status: 'completed',
|
||
metadata: {
|
||
bet_id: bet.id,
|
||
round_id: bet.round_id,
|
||
candle_open_ms: candleOpenMs,
|
||
outcome: outcome.type,
|
||
prediction_mode: 'multi_candle',
|
||
multi_level: level,
|
||
payout_multiplier: payoutMultiplier,
|
||
stake_account_kind: parseStakeAccountKind(bet.stake_account_kind),
|
||
},
|
||
});
|
||
await transactionRepository.mergeGameStakeBetStatus(bet.id, 'won');
|
||
queuePredictionReferralCommission(bet, 'won');
|
||
(0, userAdminStatsService_1.queueUserAdminStatsRefresh)(bet.user_id);
|
||
await notifyMultiBetUpdate(bet.user_id, bet.interval_minutes, null);
|
||
}
|
||
return housePnlRaw;
|
||
}
|
||
//# sourceMappingURL=candlePredictMultiService.js.map
|