games_app/backend/dist/repositories/candlePredictRepository.d.ts
2026-07-29 15:35:11 +02:00

320 lines
13 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

export type PoolWinnerRule = 'minority' | 'majority' | 'daily_revenue';
export type DailyRevenueOverflowStrategy = 'minority' | 'neutral';
export type CandlePredictConfigRow = {
id: number;
interval_minutes: number;
stake_amounts: number[];
min_stake_amount: string;
max_stake_amount: string;
pool_winner_rule: PoolWinnerRule;
allowed_intervals: number[];
prediction_window_seconds: number;
tie_tolerance_percent: string;
tie_tolerance_max_percent: string;
tie_tolerance_min_enabled: boolean;
tie_tolerance_max_enabled: boolean;
base_price: string;
payout_multiplier: string;
pool_multiplier: string;
daily_revenue_target: string;
daily_revenue_overflow_strategy: DailyRevenueOverflowStrategy;
wallet_type_code: string;
auto_modes: string[];
is_active: boolean;
prediction_single_enabled: boolean;
prediction_auto_enabled: boolean;
prediction_multi_enabled: boolean;
updated_at: Date;
};
export type CandlePredictMultiLevelRow = {
level: number;
enabled: boolean;
payout_multiplier: string;
pool_multiplier: string;
sort_order: number;
updated_at: Date;
};
export type PredictionMode = 'single' | 'multi_candle';
export type RoundOutcomeType = 'short_win' | 'long_win' | 'neutral';
export type CandlePredictRoundRow = {
id: string;
candle_open_ms: string;
interval_minutes: number;
status: 'waiting' | 'betting' | 'locked' | 'settled';
short_pool_display: string;
long_pool_display: string;
open_price: string | null;
high_price: string | null;
low_price: string | null;
close_price: string | null;
outcome: RoundOutcomeType | null;
neutral_color: 'red' | 'green' | null;
total_bets: number;
created_at: Date;
settled_at: Date | null;
};
export type CandlePredictBetRow = {
id: string;
round_id: string;
user_id: string;
direction: 'short' | 'long';
stake_raw: string;
stake_display: string;
wallet_type_id: number;
status: 'pending' | 'in_progress' | 'won' | 'lost' | 'refunded';
payout_raw: string;
is_auto: boolean;
interval_minutes: number;
stake_account_kind: 'main' | 'bonus' | 'test';
prediction_mode: PredictionMode;
sequence_directions: ('short' | 'long')[] | null;
multi_level: number | null;
sequence_step: number;
anchor_candle_open_ms: string | null;
created_at: Date;
};
export type GeneratedCandleRow = {
id: string;
candle_open_ms: string;
interval_minutes: number;
open_price: string;
high_price: string;
low_price: string;
close_price: string;
color_hint: 'red' | 'green';
outcome: RoundOutcomeType;
created_at: Date;
};
export type CandlePredictIntervalRow = {
id: number;
interval_minutes: number;
label: string;
sort_order: number;
is_active: boolean;
is_default: boolean;
prediction_window_seconds: number | null;
tie_tolerance_percent: string | null;
tie_tolerance_max_percent: string | null;
tie_tolerance_min_enabled: boolean | null;
tie_tolerance_max_enabled: boolean | null;
payout_multiplier: string | null;
pool_multiplier: string | null;
base_price: string | null;
chart_candle_limit: number;
updated_at: Date;
};
export type AutoSettingsRow = {
user_id: string;
enabled: boolean;
direction: 'short' | 'long' | null;
stake_display: string;
mode: 'each_round' | 'interval';
interval_seconds: number | null;
period_minutes: number;
stake_account_kind: 'main' | 'bonus' | 'test';
last_auto_bet_at: Date | null;
updated_at: Date;
};
export declare function getConfig(): Promise<CandlePredictConfigRow>;
export type ConfigUpdate = Partial<{
intervalMinutes: number;
stakeAmounts: number[];
minStakeAmount: number;
maxStakeAmount: number;
poolWinnerRule: PoolWinnerRule;
allowedIntervals: number[];
predictionWindowSeconds: number;
tieTolerancePercent: number;
tieToleranceMaxPercent: number;
tieToleranceMinEnabled: boolean;
tieToleranceMaxEnabled: boolean;
basePrice: number;
payoutMultiplier: number;
poolMultiplier: number;
dailyRevenueTarget: number;
dailyRevenueOverflowStrategy: DailyRevenueOverflowStrategy;
walletTypeCode: string;
autoModes: string[];
isActive: boolean;
predictionSingleEnabled: boolean;
predictionAutoEnabled: boolean;
predictionMultiEnabled: boolean;
}>;
export declare function updateConfig(update: ConfigUpdate): Promise<CandlePredictConfigRow>;
/**
* Clear per-interval enable overrides so global Neutral round toggles take effect.
* Interval rows keep optional percent overrides; only the boolean enables are reset to inherit.
*/
export declare function clearIntervalNeutralityEnabledOverrides(): Promise<void>;
export declare function getRoundByOpenMs(openMs: number, intervalMinutes: number): Promise<CandlePredictRoundRow | null>;
export declare function createRound(input: {
candleOpenMs: number;
intervalMinutes: number;
status: CandlePredictRoundRow['status'];
}): Promise<CandlePredictRoundRow>;
export declare function updateRoundStatus(id: string, status: CandlePredictRoundRow['status']): Promise<void>;
export declare function getPoolTotals(roundId: string): Promise<{
shortPool: number;
longPool: number;
}>;
/** Pools for pending single/auto predictions at maturity — real money only (excludes test wallet).
* Pool weight = stake × pool_multiplier (aligned with multi-candle pool integration). */
export declare function getGlobalPoolTotalsForMaturity(candleOpenMs: number): Promise<{
shortPool: number;
longPool: number;
}>;
export declare function listRoundsByCandleOpenMs(candleOpenMs: number): Promise<CandlePredictRoundRow[]>;
export declare function listPendingBetsForMaturity(candleOpenMs: number): Promise<CandlePredictBetRow[]>;
export declare function countPendingBetsForMaturity(candleOpenMs: number): Promise<number>;
export declare function countPendingRealMoneyBetsForMaturity(candleOpenMs: number): Promise<number>;
export declare function settleRound(id: string, data: {
open: number;
high: number;
low: number;
close: number;
outcome: RoundOutcomeType;
neutralColor: 'red' | 'green' | null;
shortPool: number;
longPool: number;
}): Promise<void>;
export declare function insertGeneratedCandle(input: {
candleOpenMs: number;
intervalMinutes: number;
open: number;
high: number;
low: number;
close: number;
colorHint: 'red' | 'green';
outcome: RoundOutcomeType;
}): Promise<void>;
export declare function listGeneratedCandles(limit?: number, intervalMinutes?: number): Promise<GeneratedCandleRow[]>;
export declare function listGeneratedCandlesPage(input: {
intervalMinutes: number;
limit: number;
beforeOpenMs?: number;
}): Promise<GeneratedCandleRow[]>;
export declare function hasOlderCandles(intervalMinutes: number, beforeOpenMs: number): Promise<boolean>;
export declare function getLastGeneratedCandle(intervalMinutes: number): Promise<{
open: number;
high: number;
low: number;
close: number;
} | null>;
export declare function getLastCandleOpenMs(intervalMinutes: number): Promise<number | null>;
export declare function hasCandle(candleOpenMs: number, intervalMinutes: number): Promise<boolean>;
export declare function getPreviousCandleOhlc(candleOpenMs: number, intervalMinutes: number): Promise<{
open: number;
high: number;
low: number;
close: number;
} | null>;
export declare function listRecentCandleOutcomes(intervalMinutes: number, limit?: number): Promise<RoundOutcomeType[]>;
export declare function incrementRoundBetCount(roundId: string): Promise<void>;
export declare function createBet(input: {
roundId: string;
userId: string;
direction: 'short' | 'long';
stakeRaw: bigint;
stakeDisplay: number;
walletTypeId: number;
intervalMinutes: number;
isAuto?: boolean;
stakeAccountKind?: 'main' | 'bonus' | 'test';
}): Promise<CandlePredictBetRow>;
export declare function getUserBetForRound(roundId: string, userId: string): Promise<CandlePredictBetRow | null>;
export declare function listPendingBetsForRound(roundId: string): Promise<CandlePredictBetRow[]>;
export declare function updateBetOutcome(betId: string, status: 'won' | 'lost' | 'refunded', payoutRaw: bigint): Promise<void>;
export declare function updateBetSequenceStep(betId: string, sequenceStep: number): Promise<void>;
export declare function listMultiLevels(): Promise<CandlePredictMultiLevelRow[]>;
export declare function listEnabledMultiLevels(): Promise<CandlePredictMultiLevelRow[]>;
export declare function getMultiLevel(level: number): Promise<CandlePredictMultiLevelRow | null>;
export type MultiLevelUpdate = {
level: number;
enabled?: boolean;
payoutMultiplier?: number;
poolMultiplier?: number;
sortOrder?: number;
};
export declare function upsertMultiLevel(input: MultiLevelUpdate): Promise<CandlePredictMultiLevelRow>;
export declare function getUserActiveMultiBet(userId: string, intervalMinutes: number): Promise<CandlePredictBetRow | null>;
export declare function createMultiCandleBet(input: {
roundId: string;
userId: string;
stakeRaw: bigint;
stakeDisplay: number;
walletTypeId: number;
intervalMinutes: number;
stakeAccountKind: 'main' | 'bonus' | 'test';
level: number;
sequenceDirections: ('short' | 'long')[];
anchorCandleOpenMs: number;
}): Promise<CandlePredictBetRow>;
/** Multi bets whose current validation candle matches this maturity open time. */
export declare function listMultiBetsForValidationAtOpenMs(candleOpenMs: number): Promise<CandlePredictBetRow[]>;
export declare function countMultiBetsForValidationAtOpenMs(candleOpenMs: number): Promise<number>;
/** Distinct candle open times where an in-progress multi bet awaits validation (≤ nowMs). */
export declare function listDueMultiValidationCandleOpenMs(nowMs: number): Promise<number[]>;
/** Real-money pool contribution from multi bets at their final candle.
* Pool weight = stake × pool_multiplier (admin-configured per level). */
export declare function getMultiCandlePoolContributions(candleOpenMs: number): Promise<{
shortPool: number;
longPool: number;
}>;
export declare function listRecentBets(userId: string, limit?: number, offset?: number, intervalMinutes?: number, stakeAccountKind?: string, status?: string): Promise<Array<CandlePredictBetRow & {
candle_open_ms: string;
}>>;
export declare function countUserPredictions(userId: string, intervalMinutes?: number, stakeAccountKind?: string, status?: string): Promise<number>;
export declare function getAutoSettings(userId: string): Promise<AutoSettingsRow | null>;
export declare function upsertAutoSettings(userId: string, input: {
enabled: boolean;
direction: 'short' | 'long' | null;
stakeDisplay: number;
mode: 'each_round' | 'interval';
intervalSeconds?: number | null;
periodMinutes?: number;
stakeAccountKind?: 'main' | 'bonus' | 'test';
}): Promise<AutoSettingsRow>;
export declare function touchAutoBet(userId: string): Promise<void>;
export declare function listEnabledAutoSettings(): Promise<AutoSettingsRow[]>;
export declare function listOverdueUnsettledRounds(nowMs: number): Promise<CandlePredictRoundRow[]>;
export declare function getRoundToSettle(intervalMinutes: number): Promise<CandlePredictRoundRow | null>;
export declare function getBettingRound(intervalMinutes: number): Promise<CandlePredictRoundRow | null>;
export declare function listActiveIntervals(): Promise<CandlePredictIntervalRow[]>;
export declare function listAllIntervals(): Promise<CandlePredictIntervalRow[]>;
export declare function getIntervalByMinutes(intervalMinutes: number): Promise<CandlePredictIntervalRow | null>;
export declare function getDefaultInterval(): Promise<CandlePredictIntervalRow | null>;
export type IntervalCreateInput = {
intervalMinutes: number;
label: string;
sortOrder?: number;
isActive?: boolean;
isDefault?: boolean;
predictionWindowSeconds?: number | null;
tieTolerancePercent?: number | null;
tieToleranceMaxPercent?: number | null;
tieToleranceMinEnabled?: boolean | null;
tieToleranceMaxEnabled?: boolean | null;
payoutMultiplier?: number | null;
poolMultiplier?: number | null;
basePrice?: number | null;
chartCandleLimit?: number;
};
export type IntervalUpdateInput = Partial<IntervalCreateInput>;
export declare function createInterval(input: IntervalCreateInput): Promise<CandlePredictIntervalRow>;
export declare function updateInterval(id: number, input: IntervalUpdateInput): Promise<CandlePredictIntervalRow | null>;
export declare function clearDefaultIntervalExcept(id: number): Promise<void>;
export declare function deleteInterval(id: number): Promise<boolean>;
export declare function countRoundsForInterval(intervalMinutes: number): Promise<number>;
export type DailyRevenueRow = {
revenue_date: string;
net_pnl_raw: string;
updated_at: Date;
};
export declare function withDailyRevenueLock<T>(fn: () => Promise<T>): Promise<T>;
/**
* Ensure today's UTC row exists and return current net_pnl_raw (locked via advisory lock caller).
*/
export declare function getOrCreateDailyRevenueNetRaw(revenueDate: string): Promise<bigint>;
export declare function addDailyRevenuePnl(revenueDate: string, pnlDeltaRaw: bigint): Promise<bigint>;
export declare function getDailyRevenueNetRaw(revenueDate: string): Promise<bigint>;
//# sourceMappingURL=candlePredictRepository.d.ts.map