games_app/backend/src/routes/index.ts

871 lines
44 KiB
TypeScript

/**
* API route definitions.
* Mounts public auth endpoints, applies authentication to protected routes, and wires controllers.
*/
import { Router } from 'express';
import { authMiddleware, requireRoles, requirePermissions } from '../middleware/auth';
import { auditAction } from '../middleware/audit';
import { asyncHandler } from '../middleware/errorHandler';
import { validateBody, validateQuery, validateParams } from '../middleware/validate';
import {
loginBodySchema,
registerBodySchema,
changePasswordBodySchema,
withdrawBodySchema,
transferBodySchema,
totpEnableBodySchema,
totpDisableBodySchema,
refreshBodySchema,
logoutBodySchema,
settingsUpdateBodySchema,
} from '../validation/schemas';
import {
forgotPasswordBodySchema,
resetPasswordBodySchema,
updateProfileBodySchema,
candlePredictBetBodySchema,
candlePredictMultiBetBodySchema,
adminUserFlagsBodySchema,
adminBatchUserFlagsBodySchema,
adminBatchSecurityBodySchema,
adminBatchLedgerCreditBodySchema,
adminUserRoleBodySchema,
adminUserRolesBodySchema,
adminLedgerCreditBodySchema,
fundRequestCreateBodySchema,
fundRequestRejectBodySchema,
approvalPolicyDraftBodySchema,
securityAlertResolveBodySchema,
securitySettingsBodySchema,
adminUserSecurityBodySchema,
bonusTransferBodySchema,
testWalletCreditBodySchema,
setupFirstAdminBodySchema,
setupPromoteAdminBodySchema,
resendVerificationBodySchema,
verifyEmailBodySchema,
gameBetBodySchema,
candlePredictAutoBodySchema,
referralSettingsBodySchema,
referralLevelBodySchema,
referralFundPoolBodySchema,
referralReasonBodySchema,
referralNoteBodySchema,
referralRegularizeBodySchema,
treasuryColdWalletBodySchema,
treasuryFundingBodySchema,
treasuryFundingConfirmBodySchema,
treasuryGasTransferBodySchema,
countryRegistrationBodySchema,
reportsBulkActionBodySchema,
adminUsersExportBodySchema,
adminDeleteUserBodySchema,
supportMessageBodySchema,
supportTypingBodySchema,
faqHelpfulBodySchema,
} from '../validation/adminSchemas';
import {
candlePredictAdminConfigBodySchema,
candlePredictIntervalCreateBodySchema,
candlePredictIntervalUpdateBodySchema,
candlePredictMultiLevelsBodySchema,
gameCreateBodySchema,
gameUpdateBodySchema,
advertisementCreateBodySchema,
advertisementUpdateBodySchema,
testWalletConfigBodySchema,
shareCardSettingsBodySchema,
soloEncouragementConfigBodySchema,
marketingLiveActivitySettingsBodySchema,
marketingPersonaCreateBodySchema,
marketingPersonaUpdateBodySchema,
supportConversationUpdateBodySchema,
faqCategoryCreateBodySchema,
faqCategoryUpdateBodySchema,
faqEntryCreateBodySchema,
faqEntryUpdateBodySchema,
} from '../validation/adminResourceSchemas';
import {
auditLogQuerySchema,
auditLogExportQuerySchema,
securityAlertsQuerySchema,
dbTamperEventsQuerySchema,
adminUsersListQuerySchema,
walletTransactionsQuerySchema,
uuidParamSchema,
alertIdParamSchema,
} from '../validation/querySchemas';
import {
apiLimiter,
loginLimiter,
verificationEmailLimiter,
passwordResetLimiter,
vpsMonitorLimiter,
} from '../middleware/rateLimit';
import * as authController from '../controllers/authController';
import * as walletController from '../controllers/walletController';
import * as withdrawalController from '../controllers/withdrawalController';
import * as transferController from '../controllers/transferController';
import * as adminController from '../controllers/adminController';
import * as userController from '../controllers/userController';
import * as settingsController from '../controllers/settingsController';
import * as overviewController from '../controllers/overviewController';
import * as analyticsController from '../controllers/analyticsController';
import * as reportsController from '../controllers/reportsController';
import * as gameController from '../controllers/gameController';
import * as advertisementController from '../controllers/advertisementController';
import * as marketingController from '../controllers/marketingController';
import * as candlePredictController from '../controllers/candlePredictController';
import * as gamePlayController from '../controllers/gamePlayController';
import * as securityController from '../controllers/securityController';
import * as treasuryController from '../controllers/treasuryController';
import * as notificationController from '../controllers/notificationController';
import * as referralController from '../controllers/referralController';
import * as adminCreditController from '../controllers/adminCreditController';
import * as testWalletController from '../controllers/testWalletController';
import * as soloEncouragementController from '../controllers/soloEncouragementController';
import * as shareCardController from '../controllers/shareCardController';
import * as mobileAppReleaseController from '../controllers/mobileAppReleaseController';
import * as sslCertificateController from '../controllers/sslCertificateController';
import * as vpsMonitorController from '../controllers/vpsMonitorController';
import { apkUpload } from '../middleware/apkUpload';
import { requireSupportedAppVersion } from '../middleware/requireSupportedAppVersion';
import {
mobileReleaseCreateBodySchema,
mobileReleaseUpdateBodySchema,
mobileUpdateSettingsBodySchema,
mobileReleaseListQuerySchema,
mobileUpdateCheckQuerySchema,
mobileUpdateEventBodySchema,
mobileReleaseIdParamSchema,
} from '../validation/mobileReleaseSchemas';
import * as countryController from '../controllers/countryController';
import * as presenceController from '../controllers/presenceController';
import * as supportController from '../controllers/supportController';
import { optionalAuthMiddleware } from '../middleware/optionalAuth';
import { supportUpload } from '../middleware/supportUpload';
import { requireStaff } from '../middleware/auth';
import * as faqController from '../controllers/faqController';
import { faqUpload } from '../middleware/faqUpload';
import { faqPdfUpload } from '../middleware/faqPdfUpload';
import * as setupController from '../controllers/setupController';
import * as fundApprovalController from '../controllers/fundApprovalController';
import * as rbacController from '../controllers/rbacController';
const router = Router();
router.use(apiLimiter);
/** One-time platform setup (before any administrator exists). */
router.get('/setup/status', setupController.getSetupStatus);
router.post('/setup/first-admin', loginLimiter, validateBody(setupFirstAdminBodySchema), setupController.createFirstAdmin);
router.post('/setup/promote-admin', loginLimiter, validateBody(setupPromoteAdminBodySchema), setupController.promoteExistingUser);
router.post('/auth/register', validateBody(registerBodySchema), asyncHandler(authController.register));
router.get('/auth/referral/validate/:code', asyncHandler(authController.validateReferralCode));
router.get('/countries', countryController.listRegistrationCountries);
router.post('/auth/login', loginLimiter, validateBody(loginBodySchema), asyncHandler(authController.login));
router.get('/auth/captcha-config', asyncHandler(authController.getCaptchaConfig));
router.get('/auth/captcha-challenge', asyncHandler(authController.getCaptchaChallenge));
router.post('/auth/refresh', validateBody(refreshBodySchema), authController.refresh);
router.post('/auth/logout', validateBody(logoutBodySchema), authController.logout);
router.post('/auth/verify-email', validateBody(verifyEmailBodySchema), authController.verifyEmail);
router.get('/auth/verify-email', authController.verifyEmail);
router.post(
'/auth/resend-verification-email',
verificationEmailLimiter,
validateBody(resendVerificationBodySchema),
authController.resendVerificationEmail
);
router.post('/auth/forgot-password', passwordResetLimiter, validateBody(forgotPasswordBodySchema), authController.forgotPassword);
router.post('/auth/reset-password', validateBody(resetPasswordBodySchema), authController.resetPassword);
router.get('/auth/reset-password/validate/:token', authController.validateResetToken);
/** Public FAQ */
router.get('/faq/categories', faqController.listPublicCategories);
router.get('/faq/categories/:slug/documents/:lang', faqController.downloadCategoryDocument);
router.get('/faq/entries/popular', faqController.listPopularFaqs);
router.get('/faq/entries', faqController.listPublicFaqs);
router.get('/faq/entries/:id', faqController.getPublicFaq);
router.post('/faq/entries/:id/view', faqController.recordView);
router.post('/faq/entries/:id/helpful', optionalAuthMiddleware, validateBody(faqHelpfulBodySchema), faqController.recordHelpful);
router.get('/faq/files/:filename', faqController.getFaqFile);
/** Public marketing reads (landing / welcome) — catalogue + social-proof feeds. */
router.get('/games', gameController.listGames);
router.get('/advertisements', advertisementController.listAdvertisements);
router.get('/marketing/daily-stats', marketingController.getDailyStats);
router.get('/marketing/activity-feed', marketingController.getActivityFeed);
router.get('/marketing/withdrawal-feed', marketingController.getWithdrawalFeed);
/** Public Share Card verification (HMAC token). */
router.get('/share-cards/verify/:token', shareCardController.verifyShareCard);
/** Public Android in-app update check / APK download / telemetry (no auth). */
router.get('/app-updates/android/latest', mobileAppReleaseController.latestAndroid);
router.get(
'/app-updates/android',
validateQuery(mobileUpdateCheckQuerySchema),
mobileAppReleaseController.checkAndroid
);
router.get(
'/app-updates/android/download/:id',
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.downloadAndroid
);
router.post(
'/app-updates/android/events',
optionalAuthMiddleware,
validateBody(mobileUpdateEventBodySchema),
mobileAppReleaseController.postEvent
);
/** Support messaging — guests (visitor token) and optional authenticated users. */
router.get(
'/support/files/:filename',
optionalAuthMiddleware,
supportController.getAttachment
);
router.post('/support/conversations/current', optionalAuthMiddleware, supportController.getOrCreateConversation);
router.post(
'/support/conversations/current/messages',
optionalAuthMiddleware,
validateBody(supportMessageBodySchema),
supportController.postCurrentMessage
);
router.post(
'/support/conversations/current/messages/attachment',
optionalAuthMiddleware,
supportController.userSendCurrentWithAttachment
);
router.post(
'/support/conversations/current/upload',
optionalAuthMiddleware,
supportUpload.single('file'),
supportController.uploadCurrentAttachment
);
router.get('/support/conversations', optionalAuthMiddleware, supportController.listMyConversations);
router.get('/support/conversations/:id/messages', optionalAuthMiddleware, supportController.getMessages);
router.post('/support/conversations/:id/messages', optionalAuthMiddleware, validateBody(supportMessageBodySchema), supportController.postMessage);
router.patch(
'/support/conversations/:id/messages/:messageId',
optionalAuthMiddleware,
validateBody(supportMessageBodySchema),
supportController.patchMessage
);
router.delete(
'/support/conversations/:id/messages/:messageId',
optionalAuthMiddleware,
supportController.removeMessage
);
router.post(
'/support/conversations/:id/messages/attachment',
optionalAuthMiddleware,
supportController.userSendWithAttachment
);
router.post('/support/conversations/:id/typing', optionalAuthMiddleware, validateBody(supportTypingBodySchema), supportController.postTyping);
router.post(
'/support/conversations/:id/upload',
optionalAuthMiddleware,
supportUpload.single('file'),
supportController.uploadAttachment
);
router.use(authMiddleware);
router.get('/me', userController.getMe);
router.get('/me/security-notifications', userController.listSecurityNotifications);
router.patch('/me/security-notifications/read-all', userController.markAllSecurityNotificationsRead);
router.patch('/me/security-notifications/:notificationId/read', userController.markSecurityNotificationRead);
router.post('/presence/ping', presenceController.pingPresence);
router.patch('/me', validateBody(updateProfileBodySchema), userController.updateMe);
router.post('/auth/change-password', validateBody(changePasswordBodySchema), asyncHandler(authController.changePassword));
router.post('/auth/logout-all', authController.logoutAll);
router.post(
'/auth/send-verification-email',
verificationEmailLimiter,
authController.sendVerificationEmail
);
router.get('/wallet-types', walletController.getWalletTypes);
router.get('/balances', walletController.getBalances);
router.get('/bonus/balances', referralController.getBonusBalances);
router.post('/bonus/transfer-to-main', validateBody(bonusTransferBodySchema), referralController.transferBonusToMain);
router.get('/test-wallet', testWalletController.getTestWalletStatus);
router.post('/test-wallet/request-credits', validateBody(testWalletCreditBodySchema), testWalletController.requestTestCredits);
router.get('/share-cards/config', shareCardController.getConfig);
router.get('/share-cards/bets/:betId', shareCardController.getBetShareCard);
router.get('/share-cards/transactions/:transactionId', shareCardController.getTransactionShareCard);
router.get('/referral/me', referralController.getMyReferralInfo);
router.get('/referral/dashboard', referralController.getMyReferralDashboard);
router.get('/referral/commissions', referralController.getMyReferralCommissions);
router.get('/deposit-address/:walletType', walletController.getDepositAddress);
router.get('/transactions', validateQuery(walletTransactionsQuerySchema), walletController.getTransactions);
router.post('/2fa/setup', authController.setup2FA);
router.post('/2fa/enable', validateBody(totpEnableBodySchema), authController.enable2FA);
router.post('/2fa/disable', validateBody(totpDisableBodySchema), authController.disable2FA);
router.post('/2fa/recovery/regenerate', authController.regenerateRecoveryCodes);
router.post(
'/withdraw',
requireSupportedAppVersion,
validateBody(withdrawBodySchema),
auditAction('withdrawal_requested', 'wallet'),
asyncHandler(withdrawalController.withdraw)
);
router.post(
'/transfer',
requireSupportedAppVersion,
validateBody(transferBodySchema),
auditAction('transfer_requested', 'wallet'),
asyncHandler(transferController.transfer)
);
router.get('/games/candle-predict/state', candlePredictController.getState);
router.get('/games/candle-predict/candles', candlePredictController.getCandles);
router.post(
'/games/candle-predict/bets',
requireSupportedAppVersion,
validateBody(candlePredictBetBodySchema),
candlePredictController.placeBet
);
router.get('/games/candle-predict/bets/outcome/:idempotencyKey', candlePredictController.getBetOutcome);
router.post(
'/games/candle-predict/bets/multi',
requireSupportedAppVersion,
validateBody(candlePredictMultiBetBodySchema),
candlePredictController.placeMultiBet
);
router.get('/games/candle-predict/bets/me', candlePredictController.getMyBets);
router.get('/games/candle-predict/auto', candlePredictController.getAutoSettings);
router.put('/games/candle-predict/auto', validateBody(candlePredictAutoBodySchema), candlePredictController.updateAutoSettings);
router.get('/games/:slug/state', gamePlayController.getState);
router.get('/games/:slug/bets/me', gamePlayController.getMyBets);
router.post('/games/:slug/bets', validateBody(gameBetBodySchema), gamePlayController.placeBet);
router.get('/games/:slug/auto', gamePlayController.getAutoSettings);
router.put('/games/:slug/auto', validateBody(candlePredictAutoBodySchema), gamePlayController.updateAutoSettings);
router.get('/games/:slug/:customAction', gamePlayController.customGet);
router.get('/games/:slug', gameController.getGame);
router.get('/admin/candle-predict/config', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.getAdminConfig);
router.patch('/admin/candle-predict/config', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictAdminConfigBodySchema), candlePredictController.updateAdminConfig);
router.get('/admin/candle-predict/intervals', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.listAdminIntervals);
router.post('/admin/candle-predict/intervals', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictIntervalCreateBodySchema), candlePredictController.createAdminInterval);
router.patch('/admin/candle-predict/intervals/:id', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictIntervalUpdateBodySchema), candlePredictController.updateAdminInterval);
router.delete('/admin/candle-predict/intervals/:id', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.deleteAdminInterval);
router.get('/admin/candle-predict/multi-levels', requireRoles('admin'), requirePermissions('games.admin'), candlePredictController.listAdminMultiLevels);
router.put('/admin/candle-predict/multi-levels', requireRoles('admin'), requirePermissions('games.admin'), validateBody(candlePredictMultiLevelsBodySchema), candlePredictController.updateAdminMultiLevels);
router.get('/admin/games', requireRoles('admin'), requirePermissions('games.admin'), gameController.listGamesAdmin);
router.get('/admin/games/implementations', requireRoles('admin'), requirePermissions('games.admin'), gameController.listImplementationsAdmin);
router.post('/admin/games', requireRoles('admin'), requirePermissions('games.admin'), validateBody(gameCreateBodySchema), gameController.createGame);
router.patch('/admin/games/:id', requireRoles('admin'), requirePermissions('games.admin'), validateBody(gameUpdateBodySchema), gameController.updateGame);
router.delete('/admin/games/:id', requireRoles('admin'), requirePermissions('games.admin'), gameController.deleteGame);
router.get('/admin/advertisements', requireRoles('admin'), requirePermissions('games.admin'), advertisementController.listAdvertisementsAdmin);
router.post('/admin/advertisements', requireRoles('admin'), requirePermissions('games.admin'), validateBody(advertisementCreateBodySchema), advertisementController.createAdvertisement);
router.patch('/admin/advertisements/:id', requireRoles('admin'), requirePermissions('games.admin'), validateBody(advertisementUpdateBodySchema), advertisementController.updateAdvertisement);
router.delete('/admin/advertisements/:id', requireRoles('admin'), requirePermissions('games.admin'), advertisementController.deleteAdvertisement);
router.get(
'/admin/marketing/live-activity-settings',
requireRoles('admin'),
requirePermissions('games.admin'),
marketingController.getLiveActivitySettings
);
router.patch(
'/admin/marketing/live-activity-settings',
requireRoles('admin'),
requirePermissions('games.admin'),
validateBody(marketingLiveActivitySettingsBodySchema),
marketingController.updateLiveActivitySettings
);
router.get(
'/admin/marketing/personas',
requireRoles('admin'),
requirePermissions('games.admin'),
marketingController.listPersonas
);
router.post(
'/admin/marketing/personas',
requireRoles('admin'),
requirePermissions('games.admin'),
validateBody(marketingPersonaCreateBodySchema),
marketingController.createPersona
);
router.patch(
'/admin/marketing/personas/:id',
requireRoles('admin'),
requirePermissions('games.admin'),
validateBody(marketingPersonaUpdateBodySchema),
marketingController.updatePersona
);
router.delete(
'/admin/marketing/personas/:id',
requireRoles('admin'),
requirePermissions('games.admin'),
marketingController.deletePersona
);
router.get('/admin/users', requireRoles('admin'), requirePermissions('users.admin'), validateQuery(adminUsersListQuerySchema), adminController.listUsers);
router.post('/admin/users/export', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminUsersExportBodySchema), adminController.startUsersExport);
router.get('/admin/users/export/:jobId', requireRoles('admin'), requirePermissions('users.admin'), adminController.getUsersExportStatus);
router.get('/admin/users/export/:jobId/download', requireRoles('admin'), requirePermissions('users.admin'), adminController.downloadUsersExport);
router.post('/admin/users/batch/flags', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminBatchUserFlagsBodySchema), adminController.batchUpdateUserFlags);
router.post('/admin/users/batch/security', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminBatchSecurityBodySchema), adminController.batchUpdateUserSecurity);
router.post('/admin/users/batch/ledger-credit', requireRoles('admin'), requirePermissions('ledger.credit'), validateBody(adminBatchLedgerCreditBodySchema), adminController.batchGrantLedgerCredit);
router.get('/admin/users/:userId', requireRoles('admin'), requirePermissions('users.admin'), adminController.getUserDetails);
router.patch('/admin/users/:userId/flags', requireRoles('admin'), requirePermissions('users.admin'), validateBody(adminUserFlagsBodySchema), adminController.updateUserFlags);
router.patch('/admin/users/:userId/role', requireRoles('admin'), requirePermissions('user.manage_roles'), validateBody(adminUserRoleBodySchema), adminController.updateUserRole);
router.patch('/admin/users/:userId/roles', requireRoles('admin'), requirePermissions('user.manage_roles'), validateBody(adminUserRolesBodySchema), adminController.updateUserRoles);
// RBAC — roles & permissions management
router.get('/admin/rbac/permissions', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.listPermissions));
router.get('/admin/rbac/roles', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.listRoles));
router.get('/admin/rbac/roles/:roleId', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.getRole));
router.post('/admin/rbac/roles', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.createRole));
router.patch('/admin/rbac/roles/:roleId', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.updateRole));
router.delete('/admin/rbac/roles/:roleId', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.deleteRole));
router.get('/admin/rbac/admin-users', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.listAdminUsers));
router.get('/admin/rbac/admin-users/:userId/permissions', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.getAdminUserPermissions));
router.patch('/admin/rbac/admin-users/:userId/permissions', requireRoles('admin'), requirePermissions('admin.rbac.manage'), asyncHandler(rbacController.updateAdminUserPermissions));
router.get('/admin/rbac/admin-users/:userId', requireRoles('admin'), requirePermissions('admin.rbac.view'), asyncHandler(rbacController.getAdminUser));
router.get('/admin/rbac/me', authMiddleware, asyncHandler(rbacController.getMyPermissions));
router.delete(
'/admin/users/:userId',
requireRoles('admin'),
requirePermissions('users.admin'),
validateBody(adminDeleteUserBodySchema),
adminController.deleteUser
);
router.post(
'/admin/fund-requests',
requirePermissions('fund_operation.request'),
validateBody(fundRequestCreateBodySchema),
fundApprovalController.createFundRequest
);
router.get('/admin/fund-requests', requireRoles('admin'), requirePermissions('fund_operation.request'), fundApprovalController.listFundRequests);
router.get('/admin/fund-requests/:id', requireRoles('admin'), requirePermissions('fund_operation.request'), fundApprovalController.getFundRequest);
router.post(
'/admin/fund-requests/:id/approve',
requirePermissions('fund_operation.approve'),
fundApprovalController.approveFundRequest
);
router.post(
'/admin/fund-requests/:id/reject',
requirePermissions('fund_operation.approve'),
validateBody(fundRequestRejectBodySchema),
fundApprovalController.rejectFundRequest
);
router.delete(
'/admin/fund-requests/:id',
requireRoles('admin'),
requirePermissions('fund_operation.request'),
fundApprovalController.cancelFundRequest
);
router.get(
'/admin/approval-policies',
requireRoles('admin'),
requirePermissions('fund_operation.approve'),
fundApprovalController.listApprovalPolicies
);
router.get(
'/admin/approval-policies/revisions',
requireRoles('admin'),
requirePermissions('fund_operation.approve'),
fundApprovalController.listPolicyRevisions
);
router.post(
'/admin/approval-policies/draft-change',
requireRoles('admin'),
requirePermissions('fund_operation.approve'),
validateBody(approvalPolicyDraftBodySchema),
fundApprovalController.draftPolicyChange
);
router.post(
'/admin/users/:userId/verify-email',
requireRoles('admin'),
requirePermissions('users.admin'),
adminController.verifyUserEmail
);
router.patch(
'/admin/users/:userId/security',
requireRoles('admin'),
requirePermissions('security.admin'),
validateBody(adminUserSecurityBodySchema),
securityController.updateUserSecurity
);
router.get(
'/admin/security/alerts',
requireRoles('admin'),
requirePermissions('security.admin'),
validateQuery(securityAlertsQuerySchema),
securityController.listAlerts
);
router.patch(
'/admin/security/alerts/:alertId',
requireRoles('admin'),
requirePermissions('security.admin'),
validateParams(alertIdParamSchema),
validateBody(securityAlertResolveBodySchema),
securityController.resolveAlert
);
router.get(
'/admin/security/settings',
requireRoles('admin'),
requirePermissions('security.admin'),
securityController.getSecuritySettings
);
router.patch(
'/admin/security/settings',
requireRoles('admin'),
requirePermissions('security.admin'),
validateBody(securitySettingsBodySchema),
securityController.updateSecuritySettings
);
router.post(
'/admin/security/integrity-check',
requireRoles('admin'),
requirePermissions('security.admin'),
securityController.runIntegrityCheck
);
router.get(
'/admin/security/db-tamper-events',
requireRoles('admin'),
requirePermissions('security.admin'),
validateQuery(dbTamperEventsQuerySchema),
securityController.listDbTamperEvents
);
router.get(
'/admin/security/db-tamper-events/export.csv',
requireRoles('admin'),
requirePermissions('security.admin'),
validateQuery(dbTamperEventsQuerySchema.omit({ limit: true, offset: true })),
securityController.exportDbTamperEventsCsv
);
router.post(
'/admin/security/db-tamper-check',
requireRoles('admin'),
requirePermissions('security.admin'),
securityController.processDbTamperCheck
);
router.post(
'/admin/security/dismiss-spurious-tamper-alerts',
requireRoles('admin'),
requirePermissions('security.admin'),
securityController.dismissSpuriousTamperAlerts
);
router.get(
'/admin/security/audit-logs',
requireRoles('admin'),
requirePermissions('security.admin'),
validateQuery(auditLogQuerySchema),
securityController.listAuditLogs
);
router.get(
'/admin/security/failed-logins',
requireRoles('admin'),
requirePermissions('security.admin'),
validateQuery(auditLogQuerySchema),
securityController.listFailedLogins
);
router.get(
'/admin/security/locked-accounts',
requireRoles('admin'),
requirePermissions('security.admin'),
securityController.listLockedAccounts
);
router.post(
'/admin/security/locked-accounts/:userId/unlock',
requireRoles('admin'),
requirePermissions('security.admin'),
securityController.unlockAccount
);
router.get(
'/admin/security/audit-logs/export.csv',
requireRoles('admin'),
requirePermissions('security.admin'),
validateQuery(auditLogExportQuerySchema),
securityController.exportAuditLogsCsv
);
router.get('/admin/notifications', requireRoles('admin'), requirePermissions('users.admin'), notificationController.listNotifications);
router.patch('/admin/notifications/read-all', requireRoles('admin'), requirePermissions('users.admin'), notificationController.markAllNotificationsRead);
router.patch('/admin/notifications/:notificationId/read', requireRoles('admin'), requirePermissions('users.admin'), notificationController.markNotificationRead);
router.post('/admin/users/:userId/ledger-credit', requireRoles('admin'), requirePermissions('ledger.credit'), validateBody(adminLedgerCreditBodySchema), adminCreditController.grantCredit);
router.get('/admin/ledger-credits', requireRoles('admin'), requirePermissions('ledger.credit'), adminCreditController.listCredits);
router.get('/admin/referral/config', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getAdminReferralConfig);
router.patch('/admin/referral/settings', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralSettingsBodySchema), referralController.updateAdminReferralSettings);
router.put('/admin/referral/levels', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralLevelBodySchema), referralController.upsertReferralLevel);
router.delete('/admin/referral/levels/:levelNumber', requireRoles('admin'), requirePermissions('referral.admin'), referralController.deleteReferralLevel);
router.get('/admin/referral/stats', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralStats);
router.get('/admin/referral/commissions/review', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralReviewQueue);
router.post('/admin/referral/commissions/:payoutId/approve', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralNoteBodySchema), referralController.approveReferralCommission);
router.post('/admin/referral/commissions/:payoutId/reject', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralReasonBodySchema), referralController.rejectReferralCommission);
router.get('/admin/referral/fraud-dashboard', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralFraudDashboard);
router.get('/admin/referral/clawbacks/export.csv', requireRoles('admin'), requirePermissions('referral.admin'), referralController.exportReferralClawbacksCsv);
router.post('/admin/referral/commissions/:payoutId/clawback', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralReasonBodySchema), referralController.clawbackReferralCommission);
router.post('/admin/referral/pool/fund', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralFundPoolBodySchema), referralController.fundBonusPool);
router.get('/admin/referral/regularization', requireRoles('admin'), requirePermissions('referral.admin'), referralController.getReferralRegularization);
router.post('/admin/referral/regularization/apply', requireRoles('admin'), requirePermissions('referral.admin'), validateBody(referralRegularizeBodySchema), referralController.applyReferralRegularization);
router.get('/admin/test-wallet/config', requireRoles('admin'), requirePermissions('settings.admin'), testWalletController.getAdminConfig);
router.patch('/admin/test-wallet/config', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(testWalletConfigBodySchema), testWalletController.updateAdminConfig);
router.get('/admin/test-wallet/credits', requireRoles('admin'), requirePermissions('settings.admin'), testWalletController.listAdminCredits);
router.get('/admin/share-cards/settings', requireRoles('admin'), requirePermissions('settings.admin'), shareCardController.getAdminSettings);
router.patch('/admin/share-cards/settings', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(shareCardSettingsBodySchema), shareCardController.updateAdminSettings);
/** Admin — mobile APK release management */
router.get(
'/admin/mobile-releases/stats',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.view'),
mobileAppReleaseController.adminStats
);
router.get(
'/admin/mobile-update-settings',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.view'),
mobileAppReleaseController.adminGetSettings
);
router.patch(
'/admin/mobile-update-settings',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateBody(mobileUpdateSettingsBodySchema),
mobileAppReleaseController.adminUpdateSettings
);
router.get(
'/admin/mobile-releases',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.view'),
validateQuery(mobileReleaseListQuerySchema),
mobileAppReleaseController.adminList
);
router.post(
'/admin/mobile-releases',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateBody(mobileReleaseCreateBodySchema),
mobileAppReleaseController.adminCreate
);
router.get(
'/admin/mobile-releases/:id',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.view'),
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.adminGet
);
router.patch(
'/admin/mobile-releases/:id',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
validateBody(mobileReleaseUpdateBodySchema),
mobileAppReleaseController.adminUpdate
);
router.post(
'/admin/mobile-releases/:id/apk',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
(req, res, next) => {
apkUpload.single('file')(req, res, (err: unknown) => {
if (!err) {
next();
return;
}
const multerErr = err as { code?: string; message?: string };
if (multerErr.code === 'LIMIT_FILE_SIZE') {
res.status(413).json({ error: 'APK exceeds maximum upload size' });
return;
}
res.status(400).json({ error: multerErr.message || 'APK upload failed' });
});
},
mobileAppReleaseController.adminUploadApk
);
router.post(
'/admin/mobile-releases/:id/submit',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.adminSubmit
);
router.post(
'/admin/mobile-releases/:id/publish',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.adminPublish
);
router.post(
'/admin/mobile-releases/:id/suspend',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.adminSuspend
);
router.post(
'/admin/mobile-releases/:id/retire',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.adminRetire
);
router.delete(
'/admin/mobile-releases/:id',
requireRoles('admin'),
requirePermissions('admin.mobile_releases.manage'),
validateParams(mobileReleaseIdParamSchema),
mobileAppReleaseController.adminDelete
);
router.get('/admin/solo-encouragement/config', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.getAdminConfig);
router.patch('/admin/solo-encouragement/config', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(soloEncouragementConfigBodySchema), soloEncouragementController.updateAdminConfig);
router.get('/admin/solo-encouragement/streaks', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.listActiveStreaks);
router.get('/admin/solo-encouragement/grants/export', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.exportGrants);
router.get('/admin/solo-encouragement/grants', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.listGrants);
router.post('/admin/solo-encouragement/grants/:grantId/grant', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.grantBonus);
router.post('/admin/solo-encouragement/grants/:grantId/reject', requireRoles('admin'), requirePermissions('settings.admin'), soloEncouragementController.rejectBonus);
router.get('/admin/countries', requireRoles('admin'), requirePermissions('settings.admin'), countryController.listCountriesAdmin);
router.post('/admin/countries/sync', requireRoles('admin'), requirePermissions('settings.admin'), countryController.syncCountriesAdmin);
router.patch('/admin/countries/:code', requireRoles('admin'), requirePermissions('settings.admin'), validateBody(countryRegistrationBodySchema), countryController.updateCountryRegistration);
router.get('/admin/treasury/overview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.getOverview);
router.get('/admin/treasury/cold-wallets', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listColdWallets);
router.post('/admin/treasury/cold-wallets', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryColdWalletBodySchema), treasuryController.setColdWallet);
router.get('/admin/treasury/sweeps', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listSweeps);
router.post('/admin/treasury/sweeps/run', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.runSweeps);
router.get('/admin/treasury/funding', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listFunding);
router.post('/admin/treasury/funding', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingBodySchema), treasuryController.requestFunding);
router.get('/admin/treasury/funding/hot-to-cold/preview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.previewHotToColdUsdt);
router.post('/admin/treasury/funding/hot-to-cold', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingBodySchema), treasuryController.requestHotToColdUsdt);
router.patch('/admin/treasury/funding/:fundingId/confirm', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryFundingConfirmBodySchema), treasuryController.confirmFunding);
router.delete('/admin/treasury/funding/:fundingId', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.cancelFunding);
router.get('/admin/treasury/stuck-deposits', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.listStuckDeposits);
router.post('/admin/treasury/stuck-deposits/scan', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.scanStuckDeposits);
router.get('/admin/treasury/gas-transfer/preview', requireRoles('admin'), requirePermissions('treasury.view'), treasuryController.previewGasTransfer);
router.post('/admin/treasury/gas-transfer', requireRoles('admin'), requirePermissions('treasury.view'), validateBody(treasuryGasTransferBodySchema), treasuryController.requestGasTransfer);
router.get('/admin/overview', requireRoles('admin'), requirePermissions('reports.admin'), overviewController.getAdminOverview);
router.get('/admin/analytics/dashboard', requireRoles('admin'), requirePermissions('reports.admin'), analyticsController.getDashboardAnalytics);
router.get('/admin/reports/catalog', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.getCatalog);
router.get('/admin/reports/export/:jobId/download', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.downloadReportExportJob);
router.get('/admin/reports/export/:jobId', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.getReportExportJobStatus);
router.post('/admin/reports/:reportKey/export/async', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.startReportExportAsync);
router.get('/admin/reports/:reportKey', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.getReport);
router.get('/admin/reports/:reportKey/export', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.exportReport);
router.post('/admin/reports/:reportKey/export', requireRoles('admin'), requirePermissions('reports.admin'), reportsController.exportReportPost);
router.post('/admin/reports/:reportKey/bulk-action', requireRoles('admin'), requirePermissions('reports.admin'), validateBody(reportsBulkActionBodySchema), reportsController.runBulkAction);
router.get(
'/admin/ssl-certificates',
requireRoles('admin'),
requirePermissions('settings.admin'),
sslCertificateController.getStatus
);
router.get(
'/admin/vps-monitor/overview',
requireRoles('admin'),
requirePermissions('admin.vps_monitor.view'),
vpsMonitorLimiter,
auditAction('vps_monitor_overview', 'vps_monitor'),
vpsMonitorController.getOverview
);
router.get(
'/admin/vps-monitor/timeseries',
requireRoles('admin'),
requirePermissions('admin.vps_monitor.view'),
vpsMonitorLimiter,
auditAction('vps_monitor_timeseries', 'vps_monitor'),
vpsMonitorController.getTimeseries
);
router.get(
'/admin/vps-monitor/containers',
requireRoles('admin'),
requirePermissions('admin.vps_monitor.view'),
vpsMonitorLimiter,
auditAction('vps_monitor_containers', 'vps_monitor'),
vpsMonitorController.getContainers
);
router.get(
'/admin/vps-monitor/services',
requireRoles('admin'),
requirePermissions('admin.vps_monitor.view'),
vpsMonitorLimiter,
auditAction('vps_monitor_services', 'vps_monitor'),
vpsMonitorController.getServices
);
router.get('/admin/settings', requireRoles('admin'), requirePermissions('settings.admin'), settingsController.getSettings);
router.patch(
'/admin/settings',
requireRoles('admin'),
requirePermissions('settings.admin'),
validateBody(settingsUpdateBodySchema),
settingsController.updateSettings
);
/** Support desk — admin and moderator. */
router.get('/admin/support/unread', requireStaff(), supportController.adminUnreadCount);
router.get('/admin/support/conversations', requireStaff(), supportController.adminListConversations);
router.get('/admin/support/conversations/:id', requireStaff(), supportController.adminGetConversation);
router.patch('/admin/support/conversations/:id', requireStaff(), validateBody(supportConversationUpdateBodySchema), supportController.adminUpdateConversation);
router.get('/admin/support/conversations/:id/messages', requireStaff(), supportController.adminGetMessages);
router.post('/admin/support/conversations/:id/messages', requireStaff(), validateBody(supportMessageBodySchema), supportController.adminPostMessage);
router.patch(
'/admin/support/conversations/:id/messages/:messageId',
requireStaff(),
validateBody(supportMessageBodySchema),
supportController.patchMessage
);
router.delete(
'/admin/support/conversations/:id/messages/:messageId',
requireStaff(),
supportController.removeMessage
);
router.post(
'/admin/support/conversations/:id/messages/attachment',
requireStaff(),
supportController.adminSendWithAttachment
);
router.post('/admin/support/conversations/:id/typing', requireStaff(), supportController.postTyping);
router.post(
'/admin/support/conversations/:id/upload',
requireStaff(),
supportUpload.single('file'),
supportController.adminUploadAttachment
);
/** FAQ management — admin and moderator. */
router.get('/admin/faq/categories', requireStaff(), faqController.adminListCategories);
router.post('/admin/faq/categories', requireStaff(), validateBody(faqCategoryCreateBodySchema), faqController.adminCreateCategory);
router.patch('/admin/faq/categories/:id', requireStaff(), validateBody(faqCategoryUpdateBodySchema), faqController.adminUpdateCategory);
router.delete('/admin/faq/categories/:id', requireStaff(), faqController.adminDeleteCategory);
router.post(
'/admin/faq/categories/:id/documents/:lang',
requireStaff(),
faqPdfUpload.single('file'),
faqController.adminUploadCategoryDocument
);
router.delete(
'/admin/faq/categories/:id/documents/:lang',
requireStaff(),
faqController.adminDeleteCategoryDocument
);
router.get('/admin/faq/entries', requireStaff(), faqController.adminListFaqs);
router.post('/admin/faq/entries', requireStaff(), validateBody(faqEntryCreateBodySchema), faqController.adminCreateFaq);
router.patch('/admin/faq/entries/:id', requireStaff(), validateBody(faqEntryUpdateBodySchema), faqController.adminUpdateFaq);
router.delete('/admin/faq/entries/:id', requireStaff(), faqController.adminDeleteFaq);
router.post('/admin/faq/upload', requireStaff(), faqUpload.single('file'), faqController.adminUploadMedia);
/** Express router mounted at config.apiPrefix (default /api/v1). */
export default router;