games_app/backend/dist-test-faq/services/shareCardService.js

485 lines
19 KiB
JavaScript
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.

"use strict";
/**
* Share Cards: eligibility, signed verify tokens, and share payloads
* for prediction results and wallet operations (deposit / withdrawal / transfer).
*/
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;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ShareCardError = void 0;
exports.mapSettingsForClient = mapSettingsForClient;
exports.isConfirmedRealDeposit = isConfirmedRealDeposit;
exports.hasConfirmedRealDeposit = hasConfirmedRealDeposit;
exports.canSharePredictionResult = canSharePredictionResult;
exports.canShareWalletOperation = canShareWalletOperation;
exports.computeResultAmount = computeResultAmount;
exports.createShareVerifyToken = createShareVerifyToken;
exports.createBetShareVerifyToken = createBetShareVerifyToken;
exports.parseShareVerifyToken = parseShareVerifyToken;
exports.buildShareVerifyUrl = buildShareVerifyUrl;
exports.getConfigForUser = getConfigForUser;
exports.getSettingsForAdmin = getSettingsForAdmin;
exports.updateSettings = updateSettings;
exports.getSharePayloadForOwner = getSharePayloadForOwner;
exports.getWalletOpSharePayloadForOwner = getWalletOpSharePayloadForOwner;
exports.getPublicVerifyPayload = getPublicVerifyPayload;
const crypto_1 = __importDefault(require("crypto"));
const config_1 = require("../config");
const connection_1 = require("../db/connection");
const publicWebUrl_1 = require("../utils/publicWebUrl");
const shareCardRepository = __importStar(require("../repositories/shareCardRepository"));
const candlePredictRepository = __importStar(require("../repositories/candlePredictRepository"));
const referralRepository = __importStar(require("../repositories/referralRepository"));
const transactionRepository = __importStar(require("../repositories/transactionRepository"));
const walletRepository = __importStar(require("../repositories/walletRepository"));
const STAKE_DECIMALS = 6;
function mapSettingsForClient(row, extras) {
const testWalletShareRequiresRealDeposit = row.test_wallet_share_requires_real_deposit !== false;
return {
enabled: Boolean(row.enabled),
allowMainWallet: Boolean(row.allow_main_wallet),
allowBonusWallet: Boolean(row.allow_bonus_wallet),
allowTestWallet: Boolean(row.allow_test_wallet),
allowWon: Boolean(row.allow_won),
allowLost: Boolean(row.allow_lost),
allowRefunded: Boolean(row.allow_refunded),
walletOpsEnabled: row.wallet_ops_enabled !== false,
allowDeposit: row.allow_deposit !== false,
allowWithdrawal: row.allow_withdrawal !== false,
allowTransfer: row.allow_transfer !== false,
testWalletShareRequiresRealDeposit,
// Alias for clients that still read the old referral-tied field.
referrerMustHaveDeposited: testWalletShareRequiresRealDeposit,
hasDeposited: extras?.hasDeposited === true,
updatedAt: row.updated_at.toISOString(),
};
}
/**
* A real-funds deposit is a ledger `deposit` that reached `completed`.
* Test-wallet credits, bonus grants, admin adjustments, pending/failed
* deposits, and the current Main Wallet balance are ignored.
*/
function isConfirmedRealDeposit(tx) {
return tx.type === 'deposit' && tx.status === 'completed';
}
function hasConfirmedRealDeposit(history) {
return history.some(isConfirmedRealDeposit);
}
async function userHasConfirmedRealDeposit(userId) {
const rows = await (0, connection_1.query)(`SELECT 1 AS n
FROM transactions
WHERE user_id = $1
AND type = 'deposit'
AND status = 'completed'
LIMIT 1`, [userId]);
return Boolean(rows[0]);
}
function canSharePredictionResult(settings, input) {
if (!settings.enabled)
return false;
if (input.status !== 'won' && input.status !== 'lost' && input.status !== 'refunded') {
return false;
}
if (input.stakeAccountKind === 'main' && !settings.allow_main_wallet)
return false;
if (input.stakeAccountKind === 'bonus' && !settings.allow_bonus_wallet)
return false;
if (input.stakeAccountKind === 'test') {
if (!settings.allow_test_wallet)
return false;
const requiresDeposit = input.testWalletShareRequiresRealDeposit ??
settings.test_wallet_share_requires_real_deposit !== false;
// Public verify omits hasDeposited — do not revoke an already-issued card.
if (requiresDeposit && input.hasDeposited === false)
return false;
}
if (input.status === 'won' && !settings.allow_won)
return false;
if (input.status === 'lost' && !settings.allow_lost)
return false;
if (input.status === 'refunded' && !settings.allow_refunded)
return false;
return true;
}
function canShareWalletOperation(settings, input) {
if (!settings.enabled || !settings.wallet_ops_enabled)
return false;
// Deposits tab also lists bonus credits and admin balance adjustments.
if (input.type === 'deposit' ||
input.type === 'bonus' ||
input.type === 'admin_adjustment') {
return settings.allow_deposit;
}
if (input.type === 'withdrawal')
return settings.allow_withdrawal;
if (input.type === 'transfer')
return settings.allow_transfer;
return false;
}
function rawToDisplay(raw, decimals = STAKE_DECIMALS) {
const neg = raw < 0n;
const abs = neg ? -raw : raw;
const base = 10n ** BigInt(decimals);
const whole = abs / base;
const frac = (abs % base).toString().padStart(decimals, '0');
const trimmed = frac.replace(/0+$/, '');
const body = trimmed ? `${whole}.${trimmed}` : whole.toString();
return neg ? `-${body}` : body;
}
/**
* Amount shown on share cards — matches Wallet/Recent Predictions UI:
* - won: full payout (stake + profit), e.g. +9.5
* - lost: −stake
* - refunded: +payout when stake is returned, else 0
*/
function computeResultAmount(status, stakeRaw, payoutRaw) {
if (status === 'won') {
const display = rawToDisplay(payoutRaw);
return {
resultSignedDisplay: `+${display}`,
resultRaw: payoutRaw.toString(),
pnlSign: '+',
};
}
if (status === 'lost') {
const display = rawToDisplay(stakeRaw);
return {
resultSignedDisplay: `-${display}`,
resultRaw: (-stakeRaw).toString(),
pnlSign: '-',
};
}
if (payoutRaw > 0n) {
const display = rawToDisplay(payoutRaw);
return {
resultSignedDisplay: `+${display}`,
resultRaw: payoutRaw.toString(),
pnlSign: '+',
};
}
return {
resultSignedDisplay: '0',
resultRaw: '0',
pnlSign: '',
};
}
function b64url(buf) {
const b = typeof buf === 'string' ? Buffer.from(buf, 'utf8') : buf;
return b.toString('base64url');
}
function shareSecret() {
return process.env.SHARE_CARD_SECRET?.trim() || config_1.config.jwt.secret;
}
function createShareVerifyToken(kind, resourceId, userId) {
const payload = b64url(JSON.stringify({ k: kind, id: resourceId, u: userId, v: 2 }));
const sig = crypto_1.default.createHmac('sha256', shareSecret()).update(payload).digest();
return `${payload}.${b64url(sig)}`;
}
/** @deprecated Prefer createShareVerifyToken('bet', ...) — kept for call-site clarity. */
function createBetShareVerifyToken(betId, userId) {
return createShareVerifyToken('bet', betId, userId);
}
function parseShareVerifyToken(token) {
const parts = token.split('.');
if (parts.length !== 2)
return null;
const [payload, sig] = parts;
if (!payload || !sig)
return null;
const expected = b64url(crypto_1.default.createHmac('sha256', shareSecret()).update(payload).digest());
const a = Buffer.from(sig);
const b = Buffer.from(expected);
if (a.length !== b.length || !crypto_1.default.timingSafeEqual(a, b))
return null;
try {
const json = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
if (!json.u)
return null;
// v2: { k, id, u }
if (json.k === 'bet' || json.k === 'tx') {
if (!json.id)
return null;
return { kind: json.k, id: json.id, userId: json.u };
}
// v1 legacy prediction tokens: { b, u }
if (json.b) {
return { kind: 'bet', id: json.b, userId: json.u };
}
return null;
}
catch {
return null;
}
}
function buildShareVerifyUrl(token) {
return `${(0, publicWebUrl_1.getPublicWebBaseUrl)()}/share/r/${encodeURIComponent(token)}`;
}
function buildPredictionCardPayload(bet, opts) {
const status = bet.status;
const stakeRaw = BigInt(bet.stake_raw);
const payoutRaw = BigInt(bet.payout_raw);
const result = computeResultAmount(status, stakeRaw, payoutRaw);
const token = createShareVerifyToken('bet', bet.id, bet.user_id);
const verifyUrl = buildShareVerifyUrl(token);
const registerUrl = opts.referralCode
? (0, publicWebUrl_1.buildReferralRegisterLink)(opts.referralCode)
: `${(0, publicWebUrl_1.getPublicWebBaseUrl)()}/register`;
return {
kind: 'prediction',
betId: bet.id,
gameName: 'Candle Predict',
direction: bet.direction,
sequence: bet.sequence_directions,
multiLevel: bet.multi_level,
predictionMode: bet.prediction_mode,
isAuto: bet.is_auto,
status,
stakeDisplay: Number(bet.stake_display),
stakeRaw: bet.stake_raw,
payoutRaw: bet.payout_raw,
resultSignedDisplay: result.resultSignedDisplay,
resultRaw: result.resultRaw,
pnlSign: result.pnlSign,
intervalMinutes: bet.interval_minutes,
stakeAccountKind: bet.stake_account_kind,
settledAt: bet.settled_at?.toISOString() ?? bet.created_at.toISOString(),
verifyUrl,
verifyToken: token,
referralCode: opts.includeReferral ? opts.referralCode : null,
registerUrl,
};
}
function shortAssetSymbol(code) {
const base = code.split('_')[0] || code;
return base.toUpperCase();
}
/** Human network label for share cards (prefer rail metadata over ledger type). */
function shareNetworkLabel(network, assetCode) {
if (!network && !assetCode)
return null;
const code = assetCode.toUpperCase();
const net = (network || '').toUpperCase();
if (code.includes('BEP20') || net === 'BSC')
return 'BSC (BEP20)';
if (code.includes('TRC20') || net === 'TRON')
return 'TRON (TRC20)';
return network;
}
async function buildWalletOpCardPayload(tx, opts) {
const ledgerWt = await walletRepository.getWalletTypeById(tx.wallet_type_id);
const meta = (tx.metadata ?? {});
const railCode = typeof meta.rail_wallet_type === 'string'
? meta.rail_wallet_type
: typeof meta.source_wallet_type === 'string'
? meta.source_wallet_type
: null;
// Withdrawals/deposits credit a unified ledger (often USDT_TRC20) but custody/payout
// rail is stored in metadata — prefer that for share-card asset/network labels.
let displayWt = ledgerWt;
if (railCode) {
const rail = await walletRepository.getWalletTypeByCode(railCode);
if (rail)
displayWt = rail;
}
const decimals = ledgerWt?.decimals ?? STAKE_DECIMALS;
const amountRaw = BigInt(tx.amount);
const amountDisplay = rawToDisplay(amountRaw, decimals);
const assetCode = displayWt?.code ?? ledgerWt?.code ?? 'USDT';
const assetSymbol = shortAssetSymbol(assetCode);
const network = shareNetworkLabel((typeof meta.network === 'string' && meta.network.trim()
? meta.network.trim()
: null) ??
displayWt?.network ??
null, assetCode);
const token = createShareVerifyToken('tx', tx.id, tx.user_id);
const verifyUrl = buildShareVerifyUrl(token);
const registerUrl = opts.referralCode
? (0, publicWebUrl_1.buildReferralRegisterLink)(opts.referralCode)
: `${(0, publicWebUrl_1.getPublicWebBaseUrl)()}/register`;
// Share cards are marketing-facing: show received/sent principal only (no platform fee).
const signedDisplay = tx.type === 'withdrawal'
? `-${amountDisplay}`
: tx.type === 'transfer'
? amountDisplay
: `+${amountDisplay}`;
return {
kind: 'wallet',
transactionId: tx.id,
operationType: tx.type,
status: tx.status,
amountRaw: tx.amount,
amountDisplay,
amountSignedDisplay: signedDisplay,
feeRaw: '0',
assetCode,
assetSymbol,
assetName: displayWt?.name ?? assetCode,
network,
createdAt: tx.created_at.toISOString(),
blockchainTxId: tx.blockchain_tx_id,
verifyUrl,
verifyToken: token,
referralCode: opts.includeReferral ? opts.referralCode : null,
registerUrl,
};
}
async function getConfigForUser(userId) {
const [settings, hasDeposited] = await Promise.all([
shareCardRepository.getSettings(),
userHasConfirmedRealDeposit(userId),
]);
return mapSettingsForClient(settings, { hasDeposited });
}
async function getSettingsForAdmin() {
const settings = await shareCardRepository.getSettings();
return mapSettingsForClient(settings);
}
async function updateSettings(input) {
const row = await shareCardRepository.updateSettings(input);
return mapSettingsForClient(row);
}
class ShareCardError extends Error {
constructor(message, status = 400) {
super(message);
this.name = 'ShareCardError';
this.status = status;
}
}
exports.ShareCardError = ShareCardError;
async function getSharePayloadForOwner(userId, betId) {
const settings = await shareCardRepository.getSettings();
const bet = await candlePredictRepository.getBetById(betId);
if (!bet || bet.user_id !== userId) {
throw new ShareCardError('Prediction not found', 404);
}
const hasDeposited = await userHasConfirmedRealDeposit(userId);
if (!canSharePredictionResult(settings, {
stakeAccountKind: bet.stake_account_kind,
status: bet.status,
testWalletShareRequiresRealDeposit: settings.test_wallet_share_requires_real_deposit !== false,
hasDeposited,
})) {
if (bet.stake_account_kind === 'test' &&
settings.test_wallet_share_requires_real_deposit !== false &&
!hasDeposited) {
throw new ShareCardError('You must make at least one real-funds deposit before sharing Test Wallet results and using your referral link.', 403);
}
throw new ShareCardError('Sharing is not available for this prediction', 403);
}
const referralCode = await referralRepository.getUserReferralCode(userId);
return buildPredictionCardPayload(bet, { includeReferral: true, referralCode });
}
async function getWalletOpSharePayloadForOwner(userId, transactionId) {
const settings = await shareCardRepository.getSettings();
const tx = await transactionRepository.findById(transactionId);
if (!tx || tx.user_id !== userId) {
throw new ShareCardError('Transaction not found', 404);
}
if (!canShareWalletOperation(settings, { type: tx.type })) {
throw new ShareCardError('Sharing is not available for this operation', 403);
}
const referralCode = await referralRepository.getUserReferralCode(userId);
return buildWalletOpCardPayload(tx, { includeReferral: true, referralCode });
}
async function getPublicVerifyPayload(token) {
const parsed = parseShareVerifyToken(token);
if (!parsed) {
throw new ShareCardError('Invalid or tampered share token', 400);
}
const settings = await shareCardRepository.getSettings();
if (!settings.enabled) {
throw new ShareCardError('Share cards are disabled', 404);
}
if (parsed.kind === 'tx') {
if (!settings.wallet_ops_enabled) {
throw new ShareCardError('Wallet share cards are disabled', 404);
}
const tx = await transactionRepository.findById(parsed.id);
if (!tx || tx.user_id !== parsed.userId) {
throw new ShareCardError('Transaction not found', 404);
}
if (!canShareWalletOperation(settings, { type: tx.type })) {
throw new ShareCardError('This operation is no longer shareable', 404);
}
const referralCode = await referralRepository.getUserReferralCode(tx.user_id);
const card = await buildWalletOpCardPayload(tx, { includeReferral: true, referralCode });
return {
authentic: true,
kind: 'wallet',
operationType: card.operationType,
status: card.status,
amountSignedDisplay: card.amountSignedDisplay,
amountDisplay: card.amountDisplay,
assetSymbol: card.assetSymbol,
assetCode: card.assetCode,
network: card.network,
createdAt: card.createdAt,
registerUrl: card.registerUrl,
referralCode: card.referralCode,
};
}
const bet = await candlePredictRepository.getBetById(parsed.id);
if (!bet || bet.user_id !== parsed.userId) {
throw new ShareCardError('Prediction not found', 404);
}
if (!canSharePredictionResult(settings, {
stakeAccountKind: bet.stake_account_kind,
status: bet.status,
})) {
throw new ShareCardError('This result is no longer shareable', 404);
}
const referralCode = await referralRepository.getUserReferralCode(bet.user_id);
const card = buildPredictionCardPayload(bet, { includeReferral: true, referralCode });
return {
authentic: true,
kind: 'prediction',
gameName: card.gameName,
direction: card.direction,
sequence: card.sequence,
multiLevel: card.multiLevel,
predictionMode: card.predictionMode,
isAuto: card.isAuto,
status: card.status,
resultSignedDisplay: card.resultSignedDisplay,
stakeDisplay: card.stakeDisplay,
intervalMinutes: card.intervalMinutes,
settledAt: card.settledAt,
registerUrl: card.registerUrl,
referralCode: card.referralCode,
};
}
//# sourceMappingURL=shareCardService.js.map