Files
usdt/ruoyi-system/src/main/java/com/ruoyi/system/service/WalletLedgerPostingService.java
T
2026-10-14 03:38:27 -04:00

230 lines
10 KiB
Java

package com.ruoyi.system.service;
import com.ruoyi.common.exception.CustomException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.UsdtAggregationTaskItemPlus;
import com.ruoyi.system.domain.Apps;
import com.ruoyi.system.domain.AppsBalanceLedger;
import com.ruoyi.system.domain.UsdtConfig;
import com.ruoyi.system.domain.UsdtOrdersPlus;
import com.ruoyi.system.domain.WalletAddressLedger;
import com.ruoyi.system.domain.WalletAddressPlus;
import com.ruoyi.system.mapper.UsdtOrdersMapper;
import com.ruoyi.system.mapper.AppsBalanceLedgerMapper;
import com.ruoyi.system.mapper.AppsMapper;
import com.ruoyi.system.mapper.UsdtConfigMapper;
import com.ruoyi.system.mapper.WalletAddressLedgerMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import java.util.Date;
import java.math.BigDecimal;
/**
* 系统业务流水入账服务。
* 链上广播必须在调用本服务前完成,本服务只负责数据库状态与流水的原子落库。
*/
@Service
public class WalletLedgerPostingService {
private static final long STATUS_PENDING = 1L;
private static final long STATUS_PAID = 2L;
private final UsdtOrdersMapper ordersMapper;
private final WalletAddressLedgerMapper ledgerMapper;
private final IWalletAddressService walletService;
private final IUsdtAggregationTaskItemService aggregationItemService;
private final AppsMapper appsMapper;
private final AppsBalanceLedgerMapper appsLedgerMapper;
private final UsdtConfigMapper configMapper;
private final PaymentOrderOpenApiService paymentOrderOpenApiService;
public WalletLedgerPostingService(UsdtOrdersMapper ordersMapper,
WalletAddressLedgerMapper ledgerMapper,
IWalletAddressService walletService,
IUsdtAggregationTaskItemService aggregationItemService,
AppsMapper appsMapper,
AppsBalanceLedgerMapper appsLedgerMapper,
UsdtConfigMapper configMapper,
PaymentOrderOpenApiService paymentOrderOpenApiService) {
this.ordersMapper = ordersMapper;
this.ledgerMapper = ledgerMapper;
this.walletService = walletService;
this.aggregationItemService = aggregationItemService;
this.appsMapper = appsMapper;
this.appsLedgerMapper = appsLedgerMapper;
this.configMapper = configMapper;
this.paymentOrderOpenApiService = paymentOrderOpenApiService;
}
/** 将待支付订单结算为成功,同一订单重复扫描不会重复产生流水。 */
@Transactional(rollbackFor = Exception.class)
public boolean settlePaidOrder(Long orderId, String transactionId) {
UsdtOrdersPlus order = ordersMapper.selectByIdForUpdate(orderId);
if (order == null) {
throw new CustomException("订单不存在");
}
if (Long.valueOf(STATUS_PAID).equals(order.getStatus())) {
return transactionId.equals(order.getBlockTransactionId());
}
if (!Long.valueOf(STATUS_PENDING).equals(order.getStatus())) {
return false;
}
if (ordersMapper.countPaidByTransactionId(transactionId, orderId) > 0) {
return false;
}
WalletAddressPlus wallet = walletService.getByTokenAndAppId(order.getToken(), order.getAppId());
Date now = DateUtils.getNowDate();
WalletAddressLedger ledger = baseLedger(now);
ledger.setTradeNo(order.getTradeId());
ledger.setIdempotencyKey("ORDER_RECEIVE:" + order.getId() + ":USDT");
ledger.setAppId(order.getAppId());
ledger.setUserId(order.getUserId());
ledger.setWalletAddressId(wallet == null ? null : wallet.getId());
ledger.setWalletAddress(order.getToken());
ledger.setCurrency("USDT");
ledger.setBusinessType("ORDER_RECEIVE");
ledger.setDirection(1);
ledger.setAmount(order.getActualAmount());
ledger.setOrderId(order.getId());
ledger.setMerchantOrderId(order.getOrderId());
ledger.setTradeId(order.getTradeId());
ledger.setTransactionId(transactionId);
ledger.setSourceType("ORDER");
ledger.setRemark("订单支付成功");
ledgerMapper.insertSystemLedgerIgnoreDuplicate(ledger);
postOrderToAppBalance(order, transactionId, now);
if (ordersMapper.markOrderPaid(order.getId(), transactionId, now) != 1) {
return false;
}
releasePaymentSlotAfterCommit(order);
return true;
}
/** 数据库确认支付事务提交后再释放 Redis 槽位,避免回滚时提前开放相同地址和金额。 */
private void releasePaymentSlotAfterCommit(final UsdtOrdersPlus order) {
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
paymentOrderOpenApiService.releasePaidOrderSlot(order);
return;
}
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCommit() {
paymentOrderOpenApiService.releasePaidOrderSlot(order);
}
});
}
/**
* 代收订单增加应用 USDT 可用余额,并扣减配置的 TRX 手续费。
* 冻结余额仅写入流水快照,不参与本次余额计算。
*/
private void postOrderToAppBalance(UsdtOrdersPlus order, String transactionId, Date now) {
Apps app = appsMapper.selectAppsByIdForUpdate(order.getAppId());
if (app == null) {
throw new CustomException("订单所属应用不存在");
}
UsdtConfig config = configMapper.selectFirstForUpdate();
if (config == null || config.getReceiveUsdtNum() == null) {
throw new CustomException("全局配置未设置订单代收手续费");
}
BigDecimal fee = config.getReceiveUsdtNum();
if (fee.compareTo(BigDecimal.ZERO) < 0) {
throw new CustomException("订单代收手续费不能小于0");
}
BigDecimal usdtBefore = zeroIfNull(app.getUsdtBalance());
BigDecimal trxBefore = zeroIfNull(app.getTrxBalance());
BigDecimal usdtAfter = usdtBefore.add(order.getActualAmount());
BigDecimal trxAfter = trxBefore.subtract(fee);
BigDecimal usdtFrozen = zeroIfNull(app.getUsdtFrozenBalance());
BigDecimal trxFrozen = zeroIfNull(app.getTrxFrozenBalance());
appsLedgerMapper.insertSystemLedgerIgnoreDuplicate(buildAppLedger(order, transactionId,
"ORDER_RECEIVE", "USDT", 1, order.getActualAmount(), usdtBefore, usdtAfter,
usdtFrozen, "订单代收到账", now, app.getUserId()));
appsLedgerMapper.insertSystemLedgerIgnoreDuplicate(buildAppLedger(order, transactionId,
"ORDER_FEE", "TRX", 2, fee, trxBefore, trxAfter,
trxFrozen, "订单代收手续费", now, app.getUserId()));
if (appsMapper.updateAvailableBalances(app.getId(), usdtAfter, trxAfter, now) != 1) {
throw new CustomException("应用余额更新失败");
}
}
private AppsBalanceLedger buildAppLedger(UsdtOrdersPlus order, String transactionId,
String businessType, String currency, int direction, BigDecimal amount,
BigDecimal before, BigDecimal after, BigDecimal frozen,
String remark, Date now, Long userId) {
AppsBalanceLedger ledger = new AppsBalanceLedger();
ledger.setTradeNo(order.getTradeId());
ledger.setIdempotencyKey(businessType + ":" + order.getId() + ":" + currency);
ledger.setAppId(order.getAppId());
ledger.setUserId(userId);
ledger.setCurrency(currency);
ledger.setBalanceType(1);
ledger.setBusinessType(businessType);
ledger.setDirection(direction);
ledger.setAmount(amount);
ledger.setBalanceBefore(before);
ledger.setBalanceAfter(after);
ledger.setAvailableBefore(before);
ledger.setAvailableAfter(after);
ledger.setFrozenBefore(frozen);
ledger.setFrozenAfter(frozen);
ledger.setOrderId(order.getId());
ledger.setMerchantOrderId(order.getOrderId());
ledger.setTransactionId(transactionId);
ledger.setRemark(remark);
ledger.setCreatedAt(now);
return ledger;
}
private BigDecimal zeroIfNull(BigDecimal value) {
return value == null ? BigDecimal.ZERO : value;
}
/** 将已广播成功的归集明细与对应支出流水原子落库。 */
@Transactional(rollbackFor = Exception.class)
public void completeAggregationItem(UsdtAggregationTaskItemPlus item,
WalletAddressPlus wallet, String transactionId, String successRemark) {
Date now = DateUtils.getNowDate();
WalletAddressLedger ledger = baseLedger(now);
ledger.setTradeNo("AGG-" + item.getParentId() + "-" + item.getId());
ledger.setIdempotencyKey("AGGREGATION_OUT:" + item.getId() + ":USDT");
ledger.setAppId(item.getAppId());
ledger.setUserId(item.getUserId());
ledger.setWalletAddressId(wallet.getId());
ledger.setWalletAddress(item.getTokenAddress());
ledger.setCounterpartyAddress(item.getDistTokenAddress());
ledger.setCurrency("USDT");
ledger.setBusinessType("AGGREGATION_OUT");
ledger.setDirection(2);
ledger.setAmount(item.getOpeAmount());
ledger.setAggregationTaskId(item.getParentId());
ledger.setAggregationItemId(item.getId());
ledger.setTransactionId(transactionId);
ledger.setSourceType("AGGREGATION");
ledger.setRemark("USDT归集成功");
ledgerMapper.insertSystemLedgerIgnoreDuplicate(ledger);
item.setStatus(1L);
item.setRemark(successRemark);
item.setUpdatedAt(now);
if (!aggregationItemService.updateById(item)) {
throw new CustomException("归集明细状态更新失败");
}
}
private WalletAddressLedger baseLedger(Date now) {
WalletAddressLedger ledger = new WalletAddressLedger();
ledger.setStatus(1);
ledger.setCreatedAt(now);
ledger.setUpdatedAt(now);
return ledger;
}
}