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