gambling-bot-shared 0.1.53 → 1.0.0

package/dist/guild/schemas/guild.forms.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalSettingsFormSchema = exports.managerRoleFormSchema = exports.channelsFormSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const atm_forms_1 = require("../../atm/schemas/atm.forms");
+const casino_forms_1 = require("../../casino/schemas/casino.forms");
+const prediction_forms_1 = require("../../predictions/schemas/prediction.forms");
+const raffle_forms_1 = require("../../raffle/schemas/raffle.forms");
+const commonTimezones_1 = require("../constants/commonTimezones");
+exports.channelsFormSchema = zod_1.default.object({
+    atm: atm_forms_1.atmChannelsFormSchema,
+    casino: casino_forms_1.casinoChannelsFormSchema,
+    prediction: prediction_forms_1.predictionChannelsFormSchema,
+    raffle: raffle_forms_1.raffleChannelsFormSchema
+});
+exports.managerRoleFormSchema = zod_1.default.object({
+    managerRoleId: zod_1.default.string()
+});
+exports.globalSettingsFormSchema = zod_1.default.object({
+    disableRegistrations: zod_1.default.boolean(),
+    disableDeposits: zod_1.default.boolean(),
+    disableWithdrawals: zod_1.default.boolean(),
+    disableCasinoGames: zod_1.default.boolean(),
+    disableCasinoGamesForMods: zod_1.default.boolean(),
+    disablePredictions: zod_1.default.boolean(),
+    disablePredictionManagement: zod_1.default.boolean(),
+    disableRaffles: zod_1.default.boolean(),
+    disableRaffleManagement: zod_1.default.boolean(),
+    disableDailyBonus: zod_1.default.boolean(),
+    disableVip: zod_1.default.boolean(),
+    maintenanceMode: zod_1.default.boolean(),
+    timezone: zod_1.default.enum(commonTimezones_1.COMMON_TIMEZONES),
+    currencySymbol: zod_1.default
+        .string()
+        .max(8)
+        .refine((value) => value.trim().length > 0, {
+        message: 'Currency symbol is required'
+    }),
+    currencyPlacement: zod_1.default.enum(['prefix', 'suffix'])
+});

package/dist/guild/utils/normalizeGlobalSettings.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGlobalSettings = void 0;
+const commonTimezones_1 = require("../constants/commonTimezones");
+const defaultGlobalSettings_1 = require("../constants/defaultGlobalSettings");
+const coerceBool = (value, fallback) => {
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return fallback;
+};
+const normalizeCurrencySymbol = (value) => {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return defaultGlobalSettings_1.defaultGlobalSettings.currencySymbol;
+    }
+    return value.slice(0, 8);
+};
+const normalizeCurrencyPlacement = (value) => value === 'suffix' ? 'suffix' : 'prefix';
+const normalizeTimezone = (value) => {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (raw.length > 0 && commonTimezones_1.COMMON_TIMEZONES.includes(raw)) {
+        return raw;
+    }
+    return defaultGlobalSettings_1.defaultGlobalSettings.timezone;
+};
+const normalizeGlobalSettings = (settings) => ({
+    disableRegistrations: coerceBool(settings?.disableRegistrations, defaultGlobalSettings_1.defaultGlobalSettings.disableRegistrations),
+    disableDeposits: coerceBool(settings?.disableDeposits, defaultGlobalSettings_1.defaultGlobalSettings.disableDeposits),
+    disableWithdrawals: coerceBool(settings?.disableWithdrawals, defaultGlobalSettings_1.defaultGlobalSettings.disableWithdrawals),
+    disableCasinoGames: coerceBool(settings?.disableCasinoGames, defaultGlobalSettings_1.defaultGlobalSettings.disableCasinoGames),
+    disableCasinoGamesForMods: coerceBool(settings?.disableCasinoGamesForMods, defaultGlobalSettings_1.defaultGlobalSettings.disableCasinoGamesForMods),
+    disablePredictions: coerceBool(settings?.disablePredictions, defaultGlobalSettings_1.defaultGlobalSettings.disablePredictions),
+    disablePredictionManagement: coerceBool(settings?.disablePredictionManagement, defaultGlobalSettings_1.defaultGlobalSettings.disablePredictionManagement),
+    disableRaffles: coerceBool(settings?.disableRaffles, defaultGlobalSettings_1.defaultGlobalSettings.disableRaffles),
+    disableRaffleManagement: coerceBool(settings?.disableRaffleManagement, defaultGlobalSettings_1.defaultGlobalSettings.disableRaffleManagement),
+    disableDailyBonus: coerceBool(settings?.disableDailyBonus, defaultGlobalSettings_1.defaultGlobalSettings.disableDailyBonus),
+    disableVip: coerceBool(settings?.disableVip, defaultGlobalSettings_1.defaultGlobalSettings.disableVip),
+    maintenanceMode: coerceBool(settings?.maintenanceMode, defaultGlobalSettings_1.defaultGlobalSettings.maintenanceMode),
+    timezone: normalizeTimezone(settings?.timezone),
+    currencySymbol: normalizeCurrencySymbol(settings?.currencySymbol),
+    currencyPlacement: normalizeCurrencyPlacement(settings?.currencyPlacement)
+});
+exports.normalizeGlobalSettings = normalizeGlobalSettings;

package/dist/mongoose/index.js

@@ -1,24 +1,19 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./user.schema"), exports);
-__exportStar(require("./vipRoom.schema"), exports);
-__exportStar(require("./prediction.schema"), exports);
-__exportStar(require("./transaction.schema"), exports);
-__exportStar(require("./guildConfiguration.schema"), exports);
-__exportStar(require("./atmRequest.schema"), exports);
-__exportStar(require("./raffle.schema"), exports);
-__exportStar(require("./blackjackGame.schema"), exports);
+exports.BlackjackGameSchema = exports.RaffleSchema = exports.AtmRequestSchema = exports.GuildConfigurationSchema = exports.TransactionSchema = exports.PredictionSchema = exports.VipRoomSchema = exports.UserSchema = void 0;
+var user_mongoose_1 = require("../user/user.mongoose");
+Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return user_mongoose_1.UserSchema; } });
+var vipRoom_mongoose_1 = require("../vip/vipRoom.mongoose");
+Object.defineProperty(exports, "VipRoomSchema", { enumerable: true, get: function () { return vipRoom_mongoose_1.VipRoomSchema; } });
+var prediction_mongoose_1 = require("../predictions/prediction.mongoose");
+Object.defineProperty(exports, "PredictionSchema", { enumerable: true, get: function () { return prediction_mongoose_1.PredictionSchema; } });
+var transaction_mongoose_1 = require("../transactions/transaction.mongoose");
+Object.defineProperty(exports, "TransactionSchema", { enumerable: true, get: function () { return transaction_mongoose_1.TransactionSchema; } });
+var guildConfiguration_mongoose_1 = require("../guild/guildConfiguration.mongoose");
+Object.defineProperty(exports, "GuildConfigurationSchema", { enumerable: true, get: function () { return guildConfiguration_mongoose_1.GuildConfigurationSchema; } });
+var atmRequest_mongoose_1 = require("../atm/atmRequest.mongoose");
+Object.defineProperty(exports, "AtmRequestSchema", { enumerable: true, get: function () { return atmRequest_mongoose_1.AtmRequestSchema; } });
+var raffle_mongoose_1 = require("../raffle/raffle.mongoose");
+Object.defineProperty(exports, "RaffleSchema", { enumerable: true, get: function () { return raffle_mongoose_1.RaffleSchema; } });
+var blackjackGame_mongoose_1 = require("../casino/blackjackGame.mongoose");
+Object.defineProperty(exports, "BlackjackGameSchema", { enumerable: true, get: function () { return blackjackGame_mongoose_1.BlackjackGameSchema; } });

package/dist/predictions/index.js

@@ -0,0 +1,29 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictionSchema = void 0;
+__exportStar(require("./types/prediction"), exports);
+__exportStar(require("./utils/validatePredictionBet"), exports);
+__exportStar(require("./services/types"), exports);
+__exportStar(require("./services/parsePredictionChoices"), exports);
+__exportStar(require("./services/parsePredictionAutolock"), exports);
+__exportStar(require("./services/normalizePredictionInput"), exports);
+__exportStar(require("./services/predictionSummary"), exports);
+__exportStar(require("./services/prediction.db"), exports);
+__exportStar(require("./services/predictionLifecycle.service"), exports);
+__exportStar(require("./schemas/prediction.forms"), exports);
+var prediction_mongoose_1 = require("./prediction.mongoose");
+Object.defineProperty(exports, "PredictionSchema", { enumerable: true, get: function () { return prediction_mongoose_1.PredictionSchema; } });

package/dist/{mongoose/prediction.schema.js → predictions/prediction.mongoose.js}

@@ -30,14 +30,15 @@ exports.PredictionSchema = new mongoose_1.Schema({
             bets: [
                 {
                     userId: { type: String, required: true },
-                    amount: { type: Number, required: true }
+                    amount: { type: Number, required: true },
+                    betId: { type: String, required: true }
                 }
             ]
         }
     ],
     status: {
         type: String,
-        enum: ['active', 'ended', 'paid', 'canceled'],
+        enum: ['active', 'ended', 'paying', 'paid', 'canceled'],
         default: 'active'
     },
     autolock: {

package/dist/predictions/schemas/prediction.forms.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payoutPredictionFormSchema = exports.createPredictionFormSchema = exports.predictionChoiceSchema = exports.predictionChannelsFormSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const zod_2 = require("../../common/zod");
+exports.predictionChannelsFormSchema = zod_1.default.object({
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
+});
+exports.predictionChoiceSchema = zod_1.default.object({
+    choiceName: zod_1.default.string().min(1),
+    odds: zod_2.num.pipe(zod_1.default.number().positive())
+});
+exports.createPredictionFormSchema = zod_1.default.object({
+    title: zod_1.default.string().min(1).max(256),
+    choices: zod_1.default.array(exports.predictionChoiceSchema).min(2).max(3),
+    autolock: zod_1.default.string().optional()
+});
+exports.payoutPredictionFormSchema = zod_1.default.object({
+    winnerChoice: zod_1.default.string().min(1)
+});

package/dist/predictions/services/normalizePredictionInput.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePredictionChoices = normalizePredictionChoices;
+exports.normalizePredictionAutolock = normalizePredictionAutolock;
+const luxon_1 = require("luxon");
+const parsePredictionAutolock_1 = require("./parsePredictionAutolock");
+const parsePredictionChoices_1 = require("./parsePredictionChoices");
+function normalizePredictionChoices(input) {
+    if (typeof input === 'string') {
+        return (0, parsePredictionChoices_1.parsePredictionChoices)(input);
+    }
+    if (input.length < 2 || input.length > 3) {
+        return { ok: false, error: 'INVALID_COUNT' };
+    }
+    for (const choice of input) {
+        if (!choice.choiceName?.trim() ||
+            typeof choice.odds !== 'number' ||
+            Number.isNaN(choice.odds) ||
+            choice.odds <= 0) {
+            return {
+                ok: false,
+                error: 'INVALID_FORMAT',
+                detail: choice.choiceName
+            };
+        }
+    }
+    return {
+        ok: true,
+        choices: input.map((choice) => ({
+            choiceName: choice.choiceName.trim(),
+            odds: choice.odds,
+            bets: []
+        }))
+    };
+}
+function normalizePredictionAutolock(input, format) {
+    if (format === 'discord') {
+        return (0, parsePredictionAutolock_1.parsePredictionAutolock)(input);
+    }
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return { ok: false, error: 'INVALID_FORMAT' };
+    }
+    const parsed = luxon_1.DateTime.fromISO(trimmed, { zone: 'utc' });
+    if (!parsed.isValid) {
+        return { ok: false, error: 'INVALID_DATE' };
+    }
+    const autolock = parsed.toJSDate();
+    if (autolock.getTime() <= Date.now()) {
+        return { ok: false, error: 'PAST_DATE' };
+    }
+    return { ok: true, autolock };
+}

package/dist/predictions/services/parsePredictionAutolock.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePredictionAutolock = parsePredictionAutolock;
+const luxon_1 = require("luxon");
+const AUTOLOCK_REGEX = /^(\d{1,2})\.(\d{1,2})\.(\d{4}) (\d{2}):(\d{2})$/;
+function parsePredictionAutolock(input, timezone = 'Europe/Prague') {
+    const match = input.match(AUTOLOCK_REGEX);
+    if (!match) {
+        return { ok: false, error: 'INVALID_FORMAT' };
+    }
+    const [, day, month, year, hour, minute] = match.map(Number);
+    const dt = luxon_1.DateTime.fromObject({ year, month, day, hour, minute }, { zone: timezone });
+    if (!dt.isValid) {
+        return { ok: false, error: 'INVALID_DATE' };
+    }
+    if (dt.toMillis() <= Date.now()) {
+        return { ok: false, error: 'PAST_DATE' };
+    }
+    return { ok: true, autolock: dt.toJSDate() };
+}

package/dist/predictions/services/parsePredictionChoices.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePredictionChoices = parsePredictionChoices;
+function parsePredictionChoices(input) {
+    const rawChoices = input.split(',').map((c) => c.trim());
+    if (rawChoices.length < 2 || rawChoices.length > 3) {
+        return { ok: false, error: 'INVALID_COUNT' };
+    }
+    const choicesArray = [];
+    for (const item of rawChoices) {
+        const [name, odds] = item.split(':').map((x) => x.trim());
+        if (!name || !odds || Number.isNaN(Number(odds))) {
+            return {
+                ok: false,
+                error: 'INVALID_FORMAT',
+                detail: item
+            };
+        }
+        choicesArray.push({
+            choiceName: name,
+            odds: Number(odds),
+            bets: []
+        });
+    }
+    return { ok: true, choices: choicesArray };
+}

package/dist/predictions/services/prediction.db.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPredictionDb = createPredictionDb;
+function createPredictionDb(predictionModel) {
+    const getPredictionById = async ({ predictionId, guildId }) => {
+        return predictionModel.findOne({ predictionId, guildId });
+    };
+    const getPredictionToLock = async ({ status = 'active', useAutolock = true }) => {
+        const now = new Date();
+        return predictionModel.find({
+            status,
+            ...(useAutolock ? { autolock: { $lte: now } } : {})
+        });
+    };
+    const getOldPredictions = async ({ statuses, olderThanDays }) => {
+        const cutoffDate = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
+        return predictionModel.find({
+            status: { $in: statuses },
+            updatedAt: { $lte: cutoffDate }
+        });
+    };
+    const createPrediction = async ({ predictionId, guildId, channelId, creatorId, title, choices, autolock, status }) => {
+        await predictionModel.create({
+            predictionId,
+            guildId,
+            channelId,
+            creatorId,
+            title,
+            choices,
+            autolock,
+            status
+        });
+    };
+    const updatePredictionStatus = async ({ predictionId, guildId, fromStatus, toStatus }) => {
+        return predictionModel.findOneAndUpdate({
+            predictionId,
+            guildId,
+            status: Array.isArray(fromStatus) ? { $in: fromStatus } : fromStatus
+        }, { $set: { status: toStatus } }, { returnDocument: 'after' });
+    };
+    const deletePrediction = async ({ predictionId }) => {
+        await predictionModel.deleteOne({ predictionId });
+    };
+    const findPredictions = async (query) => {
+        return predictionModel.find(query).limit(25);
+    };
+    const addPredictionBet = async ({ predictionId, guildId, choiceName, userId, amount, betId }) => {
+        return predictionModel.findOneAndUpdate({
+            predictionId,
+            guildId,
+            'choices.choiceName': choiceName
+        }, {
+            $push: {
+                'choices.$.bets': {
+                    userId,
+                    amount,
+                    betId
+                }
+            }
+        });
+    };
+    return {
+        getPredictionById,
+        getPredictionToLock,
+        getOldPredictions,
+        createPrediction,
+        updatePredictionStatus,
+        deletePrediction,
+        findPredictions,
+        addPredictionBet
+    };
+}

package/dist/predictions/services/predictionLifecycle.service.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPredictionLifecycleService = createPredictionLifecycleService;
+const predictionSummary_1 = require("./predictionSummary");
+function createPredictionLifecycleService({ predictionDb, casinoBet }) {
+    const { getPredictionById, updatePredictionStatus } = predictionDb;
+    const { refundLockedBet, settleCasinoWinnings } = casinoBet;
+    const finalizePaid = async (predictionId, guildId) => {
+        const paid = await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'paying',
+            toStatus: 'paid'
+        });
+        if (!paid)
+            throw new Error('FINALIZE_FAILED');
+        return paid;
+    };
+    const rollbackPaying = async (predictionId, guildId) => {
+        await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'paying',
+            toStatus: 'ended'
+        });
+    };
+    const endPrediction = async ({ predictionId, guildId }) => {
+        return updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'active',
+            toStatus: 'ended'
+        });
+    };
+    const cancelPrediction = async ({ predictionId, guildId }) => {
+        const updatedPrediction = await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: ['active', 'ended'],
+            toStatus: 'canceled'
+        });
+        if (!updatedPrediction)
+            return null;
+        const allBets = updatedPrediction.choices.flatMap((c) => c.bets);
+        for (const bet of allBets) {
+            await refundLockedBet({
+                userId: bet.userId,
+                guildId,
+                amount: bet.amount,
+                betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                game: 'prediction'
+            });
+        }
+        return updatedPrediction;
+    };
+    const payoutPrediction = async ({ predictionId, guildId, winnerChoice }) => {
+        const prediction = await getPredictionById({ predictionId, guildId });
+        if (!prediction)
+            return { ok: false, code: 'NOT_FOUND' };
+        if (prediction.status !== 'ended') {
+            if (prediction.status === 'paid' || prediction.status === 'paying') {
+                return { ok: false, code: 'ALREADY_HANDLED' };
+            }
+            return { ok: false, code: 'INVALID_STATUS' };
+        }
+        const winner = prediction.choices.find((c) => c.choiceName === winnerChoice);
+        if (!winner)
+            return { ok: false, code: 'INVALID_WINNER' };
+        const locked = await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'ended',
+            toStatus: 'paying'
+        });
+        if (!locked)
+            return { ok: false, code: 'ALREADY_HANDLED' };
+        try {
+            const allBets = prediction.choices.flatMap((c) => c.bets);
+            if (winner.bets.length === 0) {
+                for (const bet of allBets) {
+                    await refundLockedBet({
+                        userId: bet.userId,
+                        guildId,
+                        amount: bet.amount,
+                        betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                        game: 'prediction'
+                    });
+                }
+                const paid = await finalizePaid(predictionId, guildId);
+                return { ok: true, outcome: 'refunded', prediction: paid };
+            }
+            for (const bet of winner.bets) {
+                await settleCasinoWinnings({
+                    userId: bet.userId,
+                    guildId,
+                    totalBet: bet.amount,
+                    winnings: bet.amount * winner.odds,
+                    betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                    game: 'prediction'
+                });
+            }
+            const losingChoices = prediction.choices.filter((c) => c.choiceName !== winnerChoice);
+            for (const choice of losingChoices) {
+                for (const bet of choice.bets) {
+                    await settleCasinoWinnings({
+                        userId: bet.userId,
+                        guildId,
+                        totalBet: bet.amount,
+                        winnings: 0,
+                        betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                        game: 'prediction'
+                    });
+                }
+            }
+            const paid = await finalizePaid(predictionId, guildId);
+            return {
+                ok: true,
+                outcome: 'paid',
+                prediction: paid,
+                winnerChoice
+            };
+        }
+        catch (error) {
+            await rollbackPaying(predictionId, guildId);
+            throw error;
+        }
+    };
+    return {
+        endPrediction,
+        cancelPrediction,
+        payoutPrediction
+    };
+}

package/dist/predictions/services/predictionSummary.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePredictionBetId = resolvePredictionBetId;
+exports.getPredictionCheckSummary = getPredictionCheckSummary;
+exports.calculatePredictionPayoutSummary = calculatePredictionPayoutSummary;
+function resolvePredictionBetId(bet, predictionId) {
+    return bet.betId ?? `${predictionId}:${bet.userId}`;
+}
+function getPredictionCheckSummary(prediction) {
+    const allBets = prediction.choices.flatMap((c) => c.bets);
+    const bettorCount = new Set(allBets.map((b) => b.userId)).size;
+    const totalBetAmount = allBets.reduce((acc, b) => acc + b.amount, 0);
+    const choices = prediction.choices.map((choice) => {
+        const totalBet = choice.bets.reduce((acc, b) => acc + b.amount, 0);
+        const payoutIfWins = choice.bets.reduce((acc, b) => acc + b.amount * choice.odds, 0);
+        return {
+            choiceName: choice.choiceName,
+            odds: choice.odds,
+            betCount: choice.bets.length,
+            totalBetAmount: totalBet,
+            payoutIfWins,
+            bets: choice.bets
+        };
+    });
+    return {
+        totalBetAmount,
+        bettorCount,
+        choices
+    };
+}
+function calculatePredictionPayoutSummary(prediction, winnerChoice) {
+    const winner = prediction.choices.find((c) => c.choiceName === winnerChoice);
+    if (!winner)
+        return null;
+    const totalBets = prediction.choices.flatMap((c) => c.bets);
+    const winners = winner.bets.map((b) => ({
+        userId: b.userId,
+        betAmount: b.amount,
+        winAmount: b.amount * winner.odds
+    }));
+    const losers = prediction.choices
+        .filter((c) => c.choiceName !== winnerChoice)
+        .flatMap((c) => c.bets.map((b) => ({
+        userId: b.userId,
+        betAmount: b.amount,
+        winAmount: 0
+    })));
+    const totalWon = winners.reduce((acc, w) => acc + w.winAmount, 0);
+    const totalLost = losers.reduce((acc, l) => acc + l.betAmount, 0);
+    return {
+        participants: totalBets.length,
+        winners,
+        losers,
+        totalWon,
+        totalLost,
+        casinoProfit: totalLost - totalWon
+    };
+}

package/dist/raffle/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaffleSchema = void 0;
+__exportStar(require("./types/raffle"), exports);
+__exportStar(require("./services/types"), exports);
+__exportStar(require("./services/raffle.db"), exports);
+__exportStar(require("./services/raffleLifecycle.service"), exports);
+__exportStar(require("./schemas/raffle.forms"), exports);
+var raffle_mongoose_1 = require("./raffle.mongoose");
+Object.defineProperty(exports, "RaffleSchema", { enumerable: true, get: function () { return raffle_mongoose_1.RaffleSchema; } });

package/dist/raffle/schemas/raffle.forms.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raffleCreateFormSchema = exports.raffleChannelsFormSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.raffleChannelsFormSchema = zod_1.default.object({
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
+});
+exports.raffleCreateFormSchema = zod_1.default.object({
+    ticketPrice: zod_1.default.string().min(1),
+    maxTickets: zod_1.default.number().int().min(1).max(100),
+    drawTime: zod_1.default.string().min(1),
+    interval: zod_1.default.string().min(2)
+});