提交冻结USDT,同一用户全网络仅允许一笔进行中提现。

支持后台、Telegram审核;拒绝后释放冻结。
支持管理员填写Hash核验到账、链上监听自动到账,记录到账方式和操作日志。
严格核对网络、付款方、收款方、金额及审核后交易时间,防止重复扣款。
已补齐前端申请、记录、审核、扫描状态和交易明细页面。
This commit is contained in:
lu7213 committed 2026-10-30 03:44:03 -04:00
1 parent dc2564b1d4
commit f837befe99
17 files changed
+1604 -4

No files matched your search

@@ -80,7 +80,8 @@ public class RentalChain {
json.writeValueAsString(body)))
.build();
try (Response response = client.newCall(request).execute()) {
boolean fullBlock = path.endsWith("/getnowblock") || path.endsWith("/getblockbynum");
boolean fullBlock = path.endsWith("/getnowblock") || path.endsWith("/getblockbynum")
|| path.endsWith("/gettransactioninfobyblocknum");
return json.readTree(RentalHttp.body(response,
(fullBlock ? 16 : 1) * 1024 * 1024));
}
@@ -54,6 +54,20 @@ public class RentalFunds {
long actor,
String evidence,
String reason) {
post(account, key, type, available, frozen, pending, fee, order, settlement, refund,
actor, evidence, reason, null);
}
/** 提现独立关联;与租赁冻结复用同一账户行锁、余额检查及不可变流水。 */
public void withdraw(long account, long withdraw, String type, BigDecimal available,
BigDecimal frozen, long actor, String reason) {
post(account, type + ":" + withdraw, type, available, frozen, ZERO, ZERO,
null, null, null, actor, null, reason, withdraw);
}
private void post(long account, String key, String type, BigDecimal available, BigDecimal frozen,
BigDecimal pending, BigDecimal fee, Long order, Long settlement, Long refund,
long actor, String evidence, String reason, Long withdraw) {
Map<String, Object> row = store.get("account", account, true);
Map<String, Object> old = store.one("SELECT * FROM rent_ledger WHERE business_key=?", key);
if (old != null) {
@@ -113,6 +127,8 @@ public class RentalFunds {
settlement,
"refund_id",
refund,
"withdraw_id",
withdraw,
"reversal_of_id",
reversalOf,
"operator_user_id",
@@ -26,6 +26,9 @@ public class RentalStore {
"user_package",
"account",
"topup_order",
"withdraw_order",
"withdraw_transaction",
"withdraw_scan_cursor",
"order",
"task",
"transaction",
@@ -0,0 +1,139 @@
package com.ruoyi.system.rental;
import static com.ruoyi.system.rental.RentalValues.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.ruoyi.system.service.TronServiceProvider;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.tron.trident.core.ApiWrapper;
import org.tron.trident.utils.Base58Check;
/**
* 提现只读链上适配器。不持有私钥、不广播;仅返回当前网络真实USDT合约的成功且足够确认的Transfer事件。
* RPC/证据缺失抛出异常,调用方保留冻结与扫描断点,不能将未知结果解释为付款失败。
*/
@Service
public class RentalWithdrawChain {
private static final String TRANSFER_TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
private final RentalChain chain;
private final TronServiceProvider services;
@Value("${rental.confirmations:19}")
private long confirmations;
public RentalWithdrawChain(RentalChain chain, TronServiceProvider services) {
this.chain = chain;
this.services = services;
}
/** 已固化区块上再保留配置确认深度,与既有租赁核验口径一致。 */
public long confirmedHead(String network) {
long height = chain.call(network(network), "/walletsolidity/getnowblock", map())
.path("block_header").path("raw_data").path("number").asLong(-1);
require(height >= 0 && confirmations > 0, "提现链头或确认深度无效");
return Math.max(0, height - confirmations + 1);
}
public JsonNode block(String network, long height) {
JsonNode result = chain.call(network, "/wallet/getblockbynum", map("num", height));
require(result.path("block_header").path("raw_data").path("number").asLong(-1) == height,
"提现扫描区块尚不可用");
return result;
}
public String contract(String network) {
return services.getServiceForNetwork(network(network)).contractAddress();
}
/** 一次获取整块回执,覆盖合约内部USDT转账,不能只筛选顶层调用USDT的交易。 */
public JsonNode receipts(String network, long height) {
JsonNode result = chain.call(network, "/wallet/gettransactioninfobyblocknum", map("num", height));
require(result.isArray(), "提现区块回执接口不可用,保留扫描断点");
return result;
}
public boolean relevantLog(String network, JsonNode log, java.util.Set<String> senders) {
if (!hex(contract(network)).substring(2).equalsIgnoreCase(log.path("address").asText())
|| log.path("topics").size() != 3
|| !TRANSFER_TOPIC.equalsIgnoreCase(log.path("topics").get(0).asText())) {
return false;
}
return senders.contains(topicAddress(log.path("topics").get(1).asText()));
}
/** 扫描预筛仅降低RPC量,最终仍以收据中的真实Transfer日志为准。 */
public boolean isUsdtCall(String network, JsonNode transaction) {
for (JsonNode item : transaction.path("raw_data").path("contract")) {
if ("TriggerSmartContract".equals(item.path("type").asText())
&& hex(contract(network)).equalsIgnoreCase(item.path("parameter").path("value")
.path("contract_address").asText())) {
return true;
}
}
return false;
}
public List<Map<String, Object>> events(String network, String hash) {
network(network);
require(hash != null && hash.matches("[0-9a-fA-F]{64}"), "提现交易Hash必须为64位十六进制");
hash = hash.toLowerCase(Locale.ROOT);
JsonNode receipt = chain.call(network, "/walletsolidity/gettransactioninfobyid", map("value", hash));
long height = receipt.path("blockNumber").asLong(-1);
require(height >= 0 && height <= confirmedHead(network)
&& hash.equalsIgnoreCase(receipt.path("id").asText()), "提现交易尚未确认或回执不完整");
List<Map<String, Object>> result = new ArrayList<>();
// 失败交易不会产生有效付款;不认领任何事件,资金仍保持冻结。
if ("FAILED".equals(receipt.path("result").asText())
|| !"SUCCESS".equals(receipt.path("receipt").path("result").asText("SUCCESS"))) {
return result;
}
JsonNode transaction = chain.call(network, "/wallet/gettransactionbyid", map("value", hash));
require(hash.equalsIgnoreCase(transaction.path("txID").asText()) && transaction.path("ret").size() > 0
&& "SUCCESS".equals(transaction.path("ret").get(0).path("contractRet").asText()),
"提现原交易执行结果无效");
JsonNode containingBlock = block(network, height);
long timestamp = containingBlock.path("block_header").path("raw_data").path("timestamp").asLong(-1);
require(timestamp > 0 && timestamp == receipt.path("blockTimeStamp").asLong(-1), "提现区块时间证据不一致");
JsonNode logs = receipt.path("log");
require(logs.isArray() && logs.size() <= 512, "提现交易日志缺失或过多");
String token = contract(network);
for (int index = 0; index < logs.size(); index++) {
JsonNode entry = logs.get(index);
if (!hex(token).substring(2).equalsIgnoreCase(entry.path("address").asText())
|| entry.path("topics").size() != 3
|| !TRANSFER_TOPIC.equalsIgnoreCase(entry.path("topics").get(0).asText())) {
continue;
}
String rawAmount = entry.path("data").asText();
require(rawAmount.matches("[0-9a-fA-F]{64}"), "提现Transfer金额编码错误");
BigInteger units = new BigInteger(rawAmount, 16);
// DECIMAL(65)足以覆盖正常USDT金额,异常合约数据不能导致静默截断。
require(units.toString().length() <= 59, "提现Transfer金额超出存储范围");
result.add(map("network", network, "transaction_id", hash, "log_index", index,
"token_contract", token, "from_address", topicAddress(entry.path("topics").get(1).asText()),
"to_address", topicAddress(entry.path("topics").get(2).asText()), "amount_units", units,
"amount_usdt", new BigDecimal(units).movePointLeft(6).setScale(6), "block_number", height,
"block_hash", containingBlock.path("blockID").asText(), "block_time",
LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC)));
}
return result;
}
private String hex(String address) {
return ApiWrapper.toHex(ApiWrapper.parseAddress(address));
}
private String topicAddress(String topic) {
require(topic.matches("(?i)0{24}[0-9a-f]{40}"), "提现Transfer地址编码错误");
return Base58Check.bytesToBase58(org.bouncycastle.util.encoders.Hex.decode("41" + topic.substring(24)));
}
}
@@ -0,0 +1,79 @@
package com.ruoyi.system.rental;
import static com.ruoyi.system.rental.RentalValues.*;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.service.TelegramAuditService;
import java.util.Map;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
/** 提现本人入口与管理员入口分离,用户ID始终取登录上下文,不能通过请求指定。 */
@RestController
public class RentalWithdrawController {
private final RentalWithdrawals withdrawals;
private final TelegramAuditService telegram;
public RentalWithdrawController(RentalWithdrawals withdrawals, TelegramAuditService telegram) {
this.withdrawals = withdrawals;
this.telegram = telegram;
}
@PostMapping("/rental/withdraw/create")
@PreAuthorize("@ss.hasPermi('rent:withdraw:create')")
public AjaxResult create(@RequestBody Map<String, Object> body) {
return AjaxResult.success(withdrawals.create(SecurityUtils.getUserId(), body));
}
@GetMapping("/rental/withdraw/list")
@PreAuthorize("@ss.hasPermi('rent:portal:view')")
public AjaxResult list(@RequestParam String network, @RequestParam(defaultValue = "1") int page) {
return AjaxResult.success(withdrawals.list(SecurityUtils.getUserId(), network, "", page, false));
}
@GetMapping("/rental/withdraw/{id}")
@PreAuthorize("@ss.hasPermi('rent:portal:view')")
public AjaxResult detail(@PathVariable long id) {
return AjaxResult.success(withdrawals.detail(SecurityUtils.getUserId(), id, false));
}
@GetMapping("/rental/manage/withdraw/list")
@PreAuthorize("@ss.hasPermi('rent:withdraw:list')")
public AjaxResult manageList(@RequestParam String network, @RequestParam(defaultValue = "") String status,
@RequestParam(defaultValue = "1") int page) {
return AjaxResult.success(withdrawals.list(0, network, status, page, true));
}
@GetMapping("/rental/manage/withdraw/{id}")
@PreAuthorize("@ss.hasPermi('rent:withdraw:list')")
public AjaxResult manageDetail(@PathVariable long id) {
return AjaxResult.success(withdrawals.detail(0, id, true));
}
@GetMapping("/rental/manage/withdraw/transactions")
@PreAuthorize("@ss.hasPermi('rent:withdraw:list')")
public AjaxResult transactions(@RequestParam String network, @RequestParam(defaultValue = "") String hash,
@RequestParam(defaultValue = "1") int page) {
return AjaxResult.success(withdrawals.transactions(network, hash, page));
}
@PostMapping("/rental/manage/withdraw/{id}/review")
@PreAuthorize("@ss.hasPermi('rent:withdraw:review')")
public AjaxResult review(@PathVariable long id, @RequestBody Map<String, Object> body) {
require(body.get("approve") instanceof Boolean, "approve必须为布尔值");
telegram.reviewRentalWithdrawFromBackoffice(id, Boolean.TRUE.equals(body.get("approve")), input(body, "reason", 512));
return AjaxResult.success();
}
@PostMapping("/rental/manage/withdraw/{id}/transaction")
@PreAuthorize("@ss.hasPermi('rent:withdraw:execute')")
public AjaxResult transaction(@PathVariable long id, @RequestBody Map<String, Object> body) {
return AjaxResult.success(withdrawals.manual(id, body, SecurityUtils.getUserId()));
}
}
@@ -0,0 +1,129 @@
package com.ruoyi.system.rental;
import static com.ruoyi.system.rental.RentalValues.*;
import com.fasterxml.jackson.databind.JsonNode;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
* 提现自动到账扫描。已确认区块按持久游标读取,先保存全部相关事件再推进断点。
* 多实例使用短租约和owner条件更新;RPC异常/进程退出后重扫,事件与资金流水唯一键保证幂等。
*/
@Slf4j
@Component
@ConditionalOnProperty(name = "rental.enabled", havingValue = "true")
public class RentalWithdrawScanner {
private final RentalStore store;
private final RentalWithdrawals withdrawals;
private final RentalWithdrawChain chain;
private final Environment environment;
public RentalWithdrawScanner(RentalStore store, RentalWithdrawals withdrawals,
RentalWithdrawChain chain, Environment environment) {
this.store = store;
this.withdrawals = withdrawals;
this.chain = chain;
this.environment = environment;
}
@Scheduled(fixedDelayString = "${rental.withdraw.poll-interval-ms:10000}")
public void tick() {
if (!environment.getProperty("rental.withdraw.scan-enabled", Boolean.class, false)) { return; }
for (String network : new String[] {"NILE", "MAINNET"}) {
try { scan(network); }
catch (Exception ex) {
store.execute("UPDATE rent_withdraw_scan_cursor SET last_error=?,updated_at=? WHERE network=?",
"扫描尚未完成,请检查RPC及服务日志,资金继续冻结", now(), network);
log.warn("提现自动扫描待重试 network={} diagnostic={}", network, RentalDiagnostics.describe(ex));
}
}
}
public void scan(String network) {
List<Map<String, Object>> orders = store.rows("SELECT * FROM rent_withdraw_order WHERE network=?"
+ " AND status IN ('EXECUTING','VERIFYING','MANUAL_REVIEW') ORDER BY approved_at,id", network);
if (orders.isEmpty()) { return; }
long head = chain.confirmedHead(network);
Map<String, Object> cursor = store.one("SELECT * FROM rent_withdraw_scan_cursor WHERE network=?", network);
if (cursor == null) {
// 首次启动二分定位最早审批时间之前的区块,不从当前链头开始导致停机付款遗漏。
long first = beforeApproval(network, head, time(orders.get(0).get("approved_at")).toEpochMilli());
store.execute("INSERT INTO rent_withdraw_scan_cursor(network,last_block,version,created_at,updated_at)"
+ " VALUES(?,?,0,?,?) ON DUPLICATE KEY UPDATE network=network", network, Math.max(-1, first - 1), now(), now());
}
String lease = id("WS");
if (store.execute("UPDATE rent_withdraw_scan_cursor SET lock_owner=?,lock_until=?,updated_at=?"
+ " WHERE network=? AND (lock_until IS NULL OR lock_until<?)", lease, after(120), now(), network, now()) != 1) { return; }
try {
cursor = store.one("SELECT * FROM rent_withdraw_scan_cursor WHERE network=?", network);
long last = number(cursor, "last_block");
int batch = Math.max(1, Math.min(100, environment.getProperty("rental.withdraw.scan-batch-blocks", Integer.class, 5)));
Set<String> allowed = new HashSet<>(withdrawals.senders(network));
for (Map<String, Object> order : orders) { allowed.addAll(withdrawals.snapshotSenders(order)); }
for (int count = 0; count < batch && last < head; count++) {
require(store.execute("UPDATE rent_withdraw_scan_cursor SET lock_until=? WHERE network=? AND lock_owner=? AND lock_until>?",
after(120), network, lease, now()) == 1, "提现扫描租约已失效");
long height = last + 1;
JsonNode block = chain.block(network, height);
JsonNode receipts = chain.receipts(network, height);
// 预先核对所有智能合约交易均有回执,不能把节点返回的部分回执当成完整区块推进游标。
Set<String> available = new HashSet<>();
for (JsonNode receipt : receipts) { available.add(receipt.path("id").asText()); }
for (JsonNode transaction : block.path("transactions")) {
for (JsonNode contract : transaction.path("raw_data").path("contract")) {
if ("TriggerSmartContract".equals(contract.path("type").asText())) {
require(available.contains(transaction.path("txID").asText()), "提现扫描区块回执不完整");
}
}
}
List<Long> eventIds = new ArrayList<>();
for (JsonNode receipt : receipts) {
boolean relevant = false;
for (JsonNode entry : receipt.path("log")) {
if (chain.relevantLog(network, entry, allowed)) { relevant = true; break; }
}
if (!relevant) { continue; }
for (Map<String, Object> event : chain.events(network, receipt.path("id").asText())) {
if (allowed.contains(text(event, "from_address"))) {
long eventId = withdrawals.record(event, "SCAN");
eventIds.add(eventId);
log.debug("提现扫描事件 network={} block={} hash={} logIndex={} eventId={}",
network, height, event.get("transaction_id"), event.get("log_index"), eventId);
}
}
}
// 整块证据先落库,再匹配,避免同一块内多笔相同付款被错误地先到先得。
for (Long eventId : eventIds) { withdrawals.autoMatch(eventId); }
require(store.execute("UPDATE rent_withdraw_scan_cursor SET last_block=?,last_error=NULL,updated_at=?"
+ " WHERE network=? AND lock_owner=? AND last_block=? AND lock_until>?",
height, now(), network, lease, last, now()) == 1, "提现扫描断点更新冲突,下次重扫");
last = height;
}
store.execute("UPDATE rent_withdraw_order SET last_check_at=? WHERE network=? AND status IN ('EXECUTING','VERIFYING','MANUAL_REVIEW')", now(), network);
log.debug("提现扫描完成 network={} cursor={} confirmedHead={} backlog={}", network, last, head, head - last);
} finally {
store.execute("UPDATE rent_withdraw_scan_cursor SET lock_owner=NULL,lock_until=NULL WHERE network=? AND lock_owner=?", network, lease);
}
}
private long beforeApproval(String network, long head, long approvedAt) {
long low = 0;
long high = head;
while (low < high) {
long middle = low + (high - low + 1) / 2;
long timestamp = chain.block(network, middle).path("block_header").path("raw_data").path("timestamp").asLong(-1);
require(timestamp > 0, "提现扫描定位缺少区块时间");
if (timestamp < approvedAt) { low = middle; } else { high = middle - 1; }
}
return low;
}
}
@@ -0,0 +1,444 @@
package com.ruoyi.system.rental;
import static com.ruoyi.system.rental.RentalValues.*;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.system.domain.TelegramAuditRecord;
import com.ruoyi.system.mapper.TelegramAuditMapper;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.env.Environment;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
/**
* 租赁提现唯一业务入口。RPC与数据库事务分离;资金状态以提现单行锁保护。
* 人工和自动完成复用同一事务,未知链上结果绝不释放冻结,不提供直接改余额/强制到账接口。
*/
@Slf4j
@Service
public class RentalWithdrawals {
public static final String TELEGRAM_TYPE = "RENT_WITHDRAW";
private static final List<String> EXECUTABLE = Arrays.asList("EXECUTING", "VERIFYING", "MANUAL_REVIEW");
private final RentalStore store;
private final RentalFunds funds;
private final RentalWithdrawChain chain;
private final Environment environment;
private final ObjectMapper json;
private final TelegramAuditMapper telegram;
private final TransactionTemplate transactions;
public RentalWithdrawals(RentalStore store, RentalFunds funds, RentalWithdrawChain chain,
Environment environment, ObjectMapper json, TelegramAuditMapper telegram,
PlatformTransactionManager manager) {
this.store = store;
this.funds = funds;
this.chain = chain;
this.environment = environment;
this.json = json;
this.telegram = telegram;
this.transactions = new TransactionTemplate(manager);
}
public boolean enabled() {
return environment.getProperty("rental.enabled", Boolean.class, false)
&& environment.getProperty("rental.withdraw.enabled", Boolean.class, false);
}
/** 余额与申请同事务提交;唯一active_user_id保证跨网络也只能有一笔进行中的提现。 */
public Map<String, Object> create(long user, Map<String, Object> request) {
String network = network(input(request, "network", 16));
String receiver = input(request, "receiver_address", 64);
RentalOrders.address(receiver);
String requestNo = input(request, "client_request_no", 64);
BigDecimal value = amount(request, "amount");
require(value.signum() > 0 && value.precision() <= 30, "提现金额须为正数且最多6位小数");
String remark = optional(request, "remark");
String hash = RentalCrypto.sha256(encode(map("network", network, "receiver", receiver,
"amount", value.toPlainString(), "remark", remark)));
log.info("提现申请检查 userId={} network={} amountUsdt={} requestNo={} enabled={}",
user, network, value, requestNo, enabled());
try {
return transactions.execute(status -> {
Map<String, Object> existing = store.one("SELECT * FROM rent_withdraw_order WHERE user_id=? AND client_request_no=?", user, requestNo);
if (existing != null) {
require(hash.equals(text(existing, "request_hash")), "提现重复请求参数不一致");
log.info("提现申请幂等命中 userId={} withdrawId={} requestNo={}", user, existing.get("id"), requestNo);
return view(existing);
}
require(enabled(), "租赁提现暂未开启");
BigDecimal minimum = new BigDecimal(environment.getProperty("rental.withdraw.min-amount-usdt", "1"));
BigDecimal maximum = new BigDecimal(environment.getProperty("rental.withdraw.max-amount-usdt", "10000"));
require(minimum.signum() > 0 && maximum.compareTo(minimum) >= 0
&& value.compareTo(minimum) >= 0 && value.compareTo(maximum) <= 0, "提现金额不在配置的允许范围内");
require(!senders(network).isEmpty(), "当前网络未配置提现付款地址");
require(store.one("SELECT id FROM rent_withdraw_order WHERE active_user_id=?", user) == null,
"您已有一笔正在处理的提现,请先查看原提现单");
Map<String, Object> account = store.one("SELECT * FROM rent_account WHERE user_id=? AND network=? FOR UPDATE", user, network);
require(account != null && "ACTIVE".equals(text(account, "status")), "资金账户不存在或已冻结");
require(amount(account, "available_amount").compareTo(value) >= 0, "账户可用USDT余额不足");
long id = store.insert("withdraw_order", map("withdraw_no", id("RW"), "user_id", user,
"account_id", account.get("id"), "network", network, "client_request_no", requestNo,
"request_hash", hash, "receiver_address", receiver, "amount", value, "frozen_amount", value,
"status", "PENDING_REVIEW", "active_user_id", user, "remark", remark));
funds.withdraw(number(account, "id"), id, "WITHDRAW_HOLD", value.negate(), value, user, "申请提现冻结USDT");
Map<String, Object> order = store.get("withdraw_order", id, false);
// 与提现同事务落持久审核队列,避免提交后进程退出导致永久漏推。
createTelegramAudit(order);
store.event("WITHDRAW", id, "CREATE", user, "申请提现并冻结USDT");
log.info("提现申请成功 withdrawId={} withdrawNo={} userId={} accountId={} network={} amountUsdt={}",
id, order.get("withdraw_no"), user, account.get("id"), network, value);
return view(order);
});
} catch (DuplicateKeyException ex) {
Map<String, Object> old = store.one("SELECT * FROM rent_withdraw_order WHERE user_id=? AND client_request_no=?", user, requestNo);
if (old != null && hash.equals(text(old, "request_hash"))) {
return view(old);
}
log.warn("提现并发申请冲突 userId={} network={} requestNo={}", user, network, requestNo);
throw new IllegalArgumentException("已有进行中的提现或重复请求参数冲突,请刷新提现记录");
} catch (RuntimeException ex) {
log.warn("提现申请未完成 userId={} network={} requestNo={} diagnostic={}",
user, network, requestNo, RentalDiagnostics.describe(ex));
throw ex;
}
}
/** 两个渠道都调用此方法;后台入口负责同步Telegram审核单,Telegram入口在原审核事务内完成。 */
public void review(long id, boolean approve, long actor, String channel, String telegramId, String reason) {
require(Arrays.asList("BACKOFFICE", "TELEGRAM").contains(channel), "审核渠道无效");
require(reason != null && !reason.trim().isEmpty() && reason.length() <= 512, "请填写审核意见,最多512字");
transactions.execute(status -> {
Map<String, Object> order = store.get("withdraw_order", id, true);
require(actor > 0 && number(order, "user_id") != actor, "不能审核自己的提现申请");
require("PENDING_REVIEW".equals(text(order, "status")), "提现已审核,请刷新查看处理结果");
Map<String, Object> changes = map("status", approve ? "EXECUTING" : "REJECTED",
"review_channel", channel, "reviewer_user_id", actor, "reviewer_telegram_id", telegramId,
"review_reason", reason.trim(), "reviewed_at", now());
if (approve) {
List<String> addresses = senders(text(order, "network"));
require(!addresses.isEmpty(), "当前网络未配置提现付款地址,不能通过审核");
changes.put("payout_sender_snapshot", encode(addresses));
changes.put("approved_at", now());
} else {
BigDecimal value = amount(order, "frozen_amount");
funds.withdraw(number(order, "account_id"), id, "WITHDRAW_RELEASE", value, value.negate(), actor, "提现审核拒绝释放冻结");
changes.put("active_user_id", null);
}
store.update("withdraw_order", id, changes);
store.event("WITHDRAW", id, approve ? "APPROVE" : "REJECT", actor, channel + ":" + reason.trim());
log.info("提现审核完成 withdrawId={} approved={} actorId={} channel={} network={}", id, approve, actor, channel, order.get("network"));
return null;
});
}
/** Telegram数字ID必须显式映射到有效后台审核员,白名单由Telegram入口另行校验。 */
public long telegramReviewer(String telegramId) {
String mappings = environment.getProperty("rental.withdraw.telegram-reviewers", "");
for (String item : mappings.split(",")) {
String[] pair = item.trim().split(":");
if (pair.length == 2 && pair[0].equals(telegramId) && pair[1].matches("[1-9][0-9]*")) {
long user = Long.parseLong(pair[1]);
Map<String, Object> allowed = store.one("SELECT u.user_id FROM sys_user u WHERE u.user_id=? AND u.status='0' AND u.del_flag='0'"
+ " AND (u.user_id=1 OR EXISTS(SELECT 1 FROM sys_user_role ur JOIN sys_role r ON r.role_id=ur.role_id"
+ " JOIN sys_role_menu rm ON rm.role_id=r.role_id JOIN sys_menu m ON m.menu_id=rm.menu_id"
+ " WHERE ur.user_id=u.user_id AND r.status='0' AND r.del_flag='0' AND m.status='0' AND m.perms='rent:withdraw:review'))", user);
require(allowed != null, "Telegram映射用户没有提现审核权限");
return user;
}
}
throw new IllegalArgumentException("未配置Telegram用户与提现审核员的映射");
}
/** 管理员登记交易与日志;未确认/不匹配只保存审计,资金继续冻结。链上调用在事务外。 */
public Map<String, Object> manual(long id, Map<String, Object> request, long actor) {
String hash = input(request, "transaction_id", 64).toLowerCase(Locale.ROOT);
require(hash.matches("[0-9a-f]{64}"), "Hash必须为64位十六进制");
String remark = input(request, "remark", 512);
Integer index = request.containsKey("log_index") && !text(request, "log_index").isEmpty()
? Math.toIntExact(number(request, "log_index")) : null;
require(index == null || index >= 0, "日志索引不能为负");
log.info("提现人工核验开始 withdrawId={} actorId={} hash={} logIndex={}", id, actor, hash, index);
Map<String, Object> order = transactions.execute(status -> {
Map<String, Object> current = store.get("withdraw_order", id, true);
require(EXECUTABLE.contains(text(current, "status")) || "COMPLETED".equals(text(current, "status")), "提现尚未审核通过");
if (!"COMPLETED".equals(text(current, "status"))) {
store.event("WITHDRAW", id, "MANUAL_SUBMIT", actor, "Hash=" + hash + ";" + remark);
store.update("withdraw_order", id, map("status", "VERIFYING"));
}
return current;
});
if ("COMPLETED".equals(text(order, "status"))) {
return detail(0, id, true);
}
try {
List<Map<String, Object>> candidates = new ArrayList<>();
for (Map<String, Object> event : chain.events(text(order, "network"), hash)) {
long eventId = record(event, "ADMIN_SUBMIT");
if ((index == null || number(event, "log_index") == index) && matches(order, event)) {
candidates.add(store.get("withdraw_transaction", eventId, false));
}
}
require(candidates.size() == 1, "没有唯一匹配的已确认提现交易,请核对网络、付款方、金额、时间及日志索引");
complete(id, number(candidates.get(0), "id"), "MANUAL", actor, remark);
} catch (RuntimeException ex) {
failure(id, "人工核验尚未通过,资金继续冻结,请核对Hash及付款条件", ex);
}
return detail(0, id, true);
}
/** 保存已确认的链上事件,重复扫描只更新时间,不覆盖原始证据或认领关系。 */
public long record(Map<String, Object> event, String source) {
return Objects.requireNonNull(transactions.execute(status -> {
String evidence = encode(map("network", event.get("network"), "tx", event.get("transaction_id"),
"log_index", event.get("log_index"), "block", event.get("block_number"), "block_hash", event.get("block_hash")));
store.execute("INSERT INTO rent_withdraw_transaction(network,transaction_id,log_index,token_contract,from_address,to_address,amount_units,amount_usdt,"
+ "block_number,block_hash,block_time,discovery_source,verify_status,match_status,evidence,last_checked_at,created_at,updated_at,version)"
+ " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,'CONFIRMED','UNMATCHED',?,?,?,?,0) ON DUPLICATE KEY UPDATE last_checked_at=?",
event.get("network"), event.get("transaction_id"), event.get("log_index"), event.get("token_contract"),
event.get("from_address"), event.get("to_address"), event.get("amount_units"), event.get("amount_usdt"),
event.get("block_number"), event.get("block_hash"), event.get("block_time"), source,
evidence, now(), now(), now(), now());
Map<String, Object> row = store.one("SELECT * FROM rent_withdraw_transaction WHERE network=? AND transaction_id=? AND log_index=? FOR UPDATE",
event.get("network"), event.get("transaction_id"), event.get("log_index"));
require(text(row, "from_address").equals(text(event, "from_address"))
&& text(row, "to_address").equals(text(event, "to_address"))
&& amount(row, "amount_usdt").compareTo(amount(event, "amount_usdt")) == 0
&& number(row, "block_number") == number(event, "block_number")
&& text(row, "token_contract").equals(text(event, "token_contract"))
&& time(row.get("block_time")).equals(time(event.get("block_time")))
&& text(row, "block_hash").equals(text(event, "block_hash")), "链上事件证据发生冲突,需人工核对");
return number(row, "id");
}));
}
public void autoMatch(long eventId) {
Map<String, Object> event = store.get("withdraw_transaction", eventId, false);
if (event.get("withdraw_id") != null) {
return;
}
List<Map<String, Object>> candidates = new ArrayList<>();
for (Map<String, Object> order : store.rows("SELECT * FROM rent_withdraw_order WHERE network=? AND receiver_address=? AND amount=?"
+ " AND status IN ('EXECUTING','VERIFYING','MANUAL_REVIEW') AND approved_at<? ORDER BY id",
event.get("network"), event.get("to_address"), event.get("amount_usdt"), event.get("block_time"))) {
if (matches(order, event)) {
candidates.add(order);
}
}
if (candidates.size() == 1) {
Map<String, Object> order = candidates.get(0);
int matchingEvents = 0;
for (Map<String, Object> payment : store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? AND to_address=?"
+ " AND amount_usdt=? AND block_time>? AND withdraw_id IS NULL AND verify_status='CONFIRMED'",
order.get("network"), order.get("receiver_address"), order.get("amount"), order.get("approved_at"))) {
if (matches(order, payment)) { matchingEvents++; }
}
if (matchingEvents > 1) {
transactions.execute(status -> {
Map<String, Object> current = store.get("withdraw_order", number(order, "id"), true);
if (EXECUTABLE.contains(text(current, "status"))) {
store.update("withdraw_order", number(order, "id"), map("status", "MANUAL_REVIEW",
"last_error", "存在多笔相同付款,请管理员指定Hash及日志索引核验"));
}
return null;
});
log.warn("提现发现多笔候选付款 withdrawId={} eventCount={},保持冻结等待人工核对", order.get("id"), matchingEvents);
return;
}
complete(number(candidates.get(0), "id"), eventId, "AUTO", 0, "链上监听自动匹配并确认到账");
} else if (candidates.size() > 1) {
transactions.execute(status -> {
// 与完成路径统一先订单后事件,避免人工核验与歧义处理反向持锁。
for (Map<String, Object> order : candidates) {
Map<String, Object> current = store.get("withdraw_order", number(order, "id"), true);
if (EXECUTABLE.contains(text(current, "status"))) {
store.update("withdraw_order", number(order, "id"), map("status", "MANUAL_REVIEW", "last_error", "交易匹配多个提现申请,请人工选择"));
}
}
store.update("withdraw_transaction", eventId, map("match_status", "AMBIGUOUS"));
return null;
});
log.warn("提现自动匹配存在歧义 eventId={} candidateCount={},不自动扣款", eventId, candidates.size());
}
}
/** 到账唯一事务:先锁提现单,再锁交易事件,最后锁资金账户;唯一事件与唯一流水双重防重。 */
public void complete(long id, long eventId, String mode, long actor, String remark) {
require(Arrays.asList("MANUAL", "AUTO").contains(mode), "到账方式无效");
transactions.execute(status -> {
Map<String, Object> order = store.get("withdraw_order", id, true);
if ("COMPLETED".equals(text(order, "status"))) {
log.info("提现到账幂等命中 withdrawId={} originalMode={}", id, order.get("arrival_mode"));
return null;
}
require(EXECUTABLE.contains(text(order, "status")), "提现未进入执行状态");
Map<String, Object> event = store.get("withdraw_transaction", eventId, true);
require("CONFIRMED".equals(text(event, "verify_status")) && event.get("withdraw_id") == null && matches(order, event),
"交易已被使用或不符合提现付款条件");
BigDecimal value = amount(order, "frozen_amount");
funds.withdraw(number(order, "account_id"), id, "WITHDRAW_COMPLETE", ZERO, value.negate(), actor, remark);
store.update("withdraw_transaction", eventId, map("withdraw_id", id, "match_status", "MATCHED"));
store.update("withdraw_order", id, map("status", "COMPLETED", "active_user_id", null,
"arrival_mode", mode, "arrival_transaction_id", eventId, "arrival_operator_id", actor == 0 ? null : actor,
"arrival_remark", remark, "completed_at", now(), "last_error", null, "last_check_at", now()));
store.event("WITHDRAW", id, "COMPLETE_" + mode, actor, "Hash=" + event.get("transaction_id") + ";" + remark);
log.info("提现到账成功 withdrawId={} network={} mode={} eventId={} hash={} logIndex={} amountUsdt={} actorId={}",
id, order.get("network"), mode, eventId, event.get("transaction_id"), event.get("log_index"), value, actor);
return null;
});
}
private boolean matches(Map<String, Object> order, Map<String, Object> event) {
return order.get("approved_at") != null && text(order, "network").equals(text(event, "network"))
&& text(order, "receiver_address").equals(text(event, "to_address"))
&& amount(order, "amount").compareTo(amount(event, "amount_usdt")) == 0
&& time(event.get("block_time")).isAfter(time(order.get("approved_at")))
&& snapshotSenders(order).contains(text(event, "from_address"));
}
public List<String> senders(String network) {
List<String> result = new ArrayList<>();
String configured = environment.getProperty("rental.withdraw." + network(network).toLowerCase(Locale.ROOT) + ".payout-addresses", "");
for (String address : configured.split(",")) {
if (!address.trim().isEmpty()) {
RentalOrders.address(address.trim());
result.add(address.trim());
}
}
return result;
}
public List<String> snapshotSenders(Map<String, Object> order) {
try {
return json.readValue(text(order, "payout_sender_snapshot"), new TypeReference<List<String>>() { });
} catch (Exception ex) {
throw new IllegalArgumentException("提现付款地址快照无效,保留冻结等待人工核对");
}
}
public Map<String, Object> list(long user, String network, String status, int page, boolean manage) {
network(network);
require(page >= 1 && page <= 100000, "页码无效");
String filter = " WHERE network=?" + (manage ? "" : " AND user_id=?") + (status.isEmpty() ? "" : " AND status=?");
List<Object> args = new ArrayList<>();
args.add(network);
if (!manage) { args.add(user); }
if (!status.isEmpty()) { args.add(status); }
List<Map<String, Object>> rows = new ArrayList<>();
for (Map<String, Object> row : store.rows("SELECT * FROM rent_withdraw_order" + filter + " ORDER BY id DESC LIMIT 20 OFFSET " + (page - 1) * 20, args.toArray())) {
rows.add(view(row));
}
Map<String, Object> active = manage ? null : store.one("SELECT * FROM rent_withdraw_order WHERE active_user_id=?", user);
Map<String, Object> cursor = manage ? store.one("SELECT last_block,updated_at,last_error FROM rent_withdraw_scan_cursor WHERE network=?", network) : null;
if (cursor != null) { cursor.put("updated_at", time(cursor.get("updated_at")).toEpochMilli()); }
return map("rows", rows, "active", active == null ? null : view(active), "enabled", enabled(),
"scan_enabled", environment.getProperty("rental.withdraw.scan-enabled", Boolean.class, false), "scan", cursor,
"min_amount", environment.getProperty("rental.withdraw.min-amount-usdt", "1"),
"max_amount", environment.getProperty("rental.withdraw.max-amount-usdt", "10000"));
}
public Map<String, Object> detail(long user, long id, boolean manage) {
Map<String, Object> order = store.get("withdraw_order", id, false);
require(manage || number(order, "user_id") == user, "无权查看此提现申请");
Map<String, Object> result = view(order);
if (manage) {
// 待审核展示当前网络配置;通过后展示审核快照,避免配置轮换误导实际付款。
result.put("payout_addresses", order.get("approved_at") == null
? senders(text(order, "network")) : snapshotSenders(order));
result.put("payout_addresses_snapshot", order.get("approved_at") != null);
}
List<Map<String, Object>> events = store.rows("SELECT action,actor_user_id,reason,created_at FROM rent_event WHERE object_type='WITHDRAW' AND object_id=? ORDER BY id", id);
for (Map<String, Object> event : events) { event.put("created_at", time(event.get("created_at")).toEpochMilli()); }
result.put("events", events);
List<Map<String, Object>> transfers = store.rows("SELECT * FROM rent_withdraw_transaction WHERE withdraw_id=?", id);
if (manage) {
transfers = store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? AND to_address=? AND block_time>? ORDER BY id DESC LIMIT 50",
order.get("network"), order.get("receiver_address"), order.get("approved_at") == null ? order.get("created_at") : order.get("approved_at"));
}
for (Map<String, Object> transfer : transfers) {
if (manage) { transfer.put("match_reason", matchReason(order, transfer)); }
for (String key : Arrays.asList("created_at", "updated_at", "last_checked_at", "block_time")) {
transfer.put(key, time(transfer.get(key)).toEpochMilli());
}
}
result.put("transactions", transfers);
return result;
}
/** 运营只读交易列表,方便定位未匹配/重复付款;不提供直接修改认领或删除证据的接口。 */
public List<Map<String, Object>> transactions(String network, String hash, int page) {
network(network);
require(page >= 1 && page <= 100000 && (hash.isEmpty() || hash.matches("[0-9a-fA-F]{64}")), "页码或交易Hash无效");
List<Map<String, Object>> rows = hash.isEmpty()
? store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? ORDER BY id DESC LIMIT 20 OFFSET " + (page - 1) * 20, network)
: store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? AND transaction_id=? ORDER BY id DESC LIMIT 20 OFFSET " + (page - 1) * 20, network, hash.toLowerCase(Locale.ROOT));
for (Map<String, Object> row : rows) {
for (String key : Arrays.asList("created_at", "updated_at", "block_time", "last_checked_at")) {
row.put(key, time(row.get(key)).toEpochMilli());
}
}
return rows;
}
private String matchReason(Map<String, Object> order, Map<String, Object> event) {
if (order.get("approved_at") == null) { return "尚未审核通过"; }
if (event.get("withdraw_id") != null) { return "已由提现单#" + event.get("withdraw_id") + "核销"; }
if (!snapshotSenders(order).contains(text(event, "from_address"))) { return "付款地址不在审核快照内"; }
if (amount(order, "amount").compareTo(amount(event, "amount_usdt")) != 0) { return "金额不一致,不合并拆分付款"; }
if (!time(event.get("block_time")).isAfter(time(order.get("approved_at")))) { return "交易时间不晚于审核时间"; }
return "AMBIGUOUS".equals(text(event, "match_status")) ? "匹配多个申请,需人工选择" : "符合当前申请付款条件";
}
private Map<String, Object> view(Map<String, Object> order) {
Map<String, Object> result = new LinkedHashMap<>(order);
result.remove("request_hash");
for (String key : Arrays.asList("created_at", "updated_at", "approved_at", "reviewed_at", "completed_at", "last_check_at")) {
result.put(key, order.get(key) == null ? null : time(order.get(key)).toEpochMilli());
}
return result;
}
private void failure(long id, String hint, RuntimeException ex) {
store.execute("UPDATE rent_withdraw_order SET last_error=?,last_check_at=?,updated_at=? WHERE id=? AND status<>'COMPLETED'", hint, now(), now(), id);
log.warn("提现核验未完成 withdrawId={} diagnostic={};保留冻结", id, RentalDiagnostics.describe(ex));
}
private void createTelegramAudit(Map<String, Object> order) {
if (!environment.getProperty("telegram.enabled", Boolean.class, false)) { return; }
TelegramAuditRecord record = new TelegramAuditRecord();
record.setAuditNo("RW-" + order.get("id") + "-" + java.util.UUID.randomUUID().toString().substring(0, 8));
record.setBusinessType(TELEGRAM_TYPE);
record.setBusinessId(text(order, "id"));
record.setTitle("租赁资金账户提现审核");
record.setAuditStatus("PENDING");
record.setPayload(encode(map("withdrawNo", order.get("withdraw_no"), "userId", order.get("user_id"),
"network", order.get("network"), "amount", order.get("amount"), "address", order.get("receiver_address"))));
Date date = new Date();
record.setCreatedAt(date);
record.setUpdatedAt(date);
telegram.insertRecord(record);
telegram.insertPushTask(record.getAuditNo(), date, date);
}
private String optional(Map<String, Object> request, String key) {
String value = text(request, key).trim();
require(value.length() <= 512 && !value.contains("\r") && !value.contains("\n"), "备注最多512字且不能换行");
return value;
}
private String encode(Object value) {
try { return json.writeValueAsString(value); }
catch (Exception ex) { throw new IllegalArgumentException("提现数据序列化失败"); }
}
}
@@ -37,6 +37,8 @@ public class TelegramAuditService {
private static final Logger LOGGER = LoggerFactory.getLogger(TelegramAuditService.class);
private static final String BUSINESS_TYPE = "USDT_AGGREGATION";
private static final String PAYOUT_BUSINESS_TYPE = "USDT_PAYOUT";
@org.springframework.beans.factory.annotation.Autowired
private com.ruoyi.system.rental.RentalWithdrawals rentalWithdrawals;
private static final int MAX_PUSH_RETRIES = 8;
private final TelegramAuditMapper mapper;
@@ -289,7 +291,11 @@ public class TelegramAuditService {
boolean approved = "A".equals(parts[2]);
String newStatus = approved ? "APPROVED" : "REJECTED";
if (PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())) {
if (com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE.equals(record.getBusinessType())) {
long reviewer = rentalWithdrawals.telegramReviewer(userId);
rentalWithdrawals.review(Long.parseLong(record.getBusinessId()), approved, reviewer,
"TELEGRAM", userId, "Telegram审核,数字用户ID=" + userId);
} else if (PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())) {
payoutOrderService.review(Long.valueOf(record.getBusinessId()), approved,
"TELEGRAM", userId, "Telegram审核");
} else {
@@ -357,6 +363,26 @@ public class TelegramAuditService {
return parts;
}
/** 后台与Telegram共用业务状态和审核记录,任一入口处理后另一入口不能覆盖决定。 */
@Transactional(rollbackFor = Exception.class)
public void reviewRentalWithdrawFromBackoffice(long id, boolean approved, String reason) {
rentalWithdrawals.review(id, approved, SecurityUtils.getUserId(), "BACKOFFICE", null, reason);
if (!enabled) { return; }
TelegramAuditRecord record = mapper.selectByBusiness(
com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE, String.valueOf(id));
if (record == null || !"PENDING".equals(record.getAuditStatus())) { return; }
String status = approved ? "APPROVED" : "REJECTED";
Date now = new Date();
if (mapper.approve(record.getAuditNo(), status, "SYSTEM", SecurityUtils.getUsername(), now, now) != 1) {
throw new CustomException("提现审核已被其他入口处理,请刷新");
}
record.setAuditStatus(status);
record.setReviewerName(SecurityUtils.getUsername());
record.setReviewerTelegramId("SYSTEM");
record.setReviewedAt(now);
afterCommit(null, record, approved ? "提现审核通过,等待付款" : "提现审核拒绝,资金已释放");
}
private void afterCommit(final String callbackId, final TelegramAuditRecord record,
final String answerText) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@@ -405,7 +431,12 @@ public class TelegramAuditService {
private Long sendAuditMessage(TelegramAuditRecord record) {
JSONObject payload = JSONObject.parseObject(record.getPayload());
String text = PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())
String text = com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE.equals(record.getBusinessType())
? "租赁提现审核\n审核单:" + record.getAuditNo() + "\n提现单:" + payload.getString("withdrawNo")
+ "\n用户:" + payload.getString("userId") + "\n网络:" + payload.getString("network")
+ "\n金额:" + payload.getString("amount") + " USDT\n收款地址:" + payload.getString("address")
+ "\n通过后仅进入执行状态,不自动转账。"
: PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())
? "代付审核\n审核单:" + record.getAuditNo() + "\n商户订单:" + payload.getString("orderId")
+ "\n金额:" + payload.getString("amount") + " " + payload.getString("currency")
+ "\n手续费:" + payload.getString("fee") + " TRX\n收款地址:" + payload.getString("address")
@@ -444,7 +475,11 @@ public class TelegramAuditService {
Map<String, Object> body = new HashMap<>();
body.put("chat_id", record.getTelegramChatId());
body.put("message_id", record.getTelegramMessageId());
String text = PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())
String text = com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE.equals(record.getBusinessType())
? "租赁提现审核 - " + result + "\n提现单:" + payload.getString("withdrawNo")
+ "\n网络:" + payload.getString("network") + "\n金额:" + payload.getString("amount")
+ " USDT\n收款地址:" + payload.getString("address") + "\n审核人:" + reviewer
: PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())
? "代付审核 - " + result + "\n审核单:" + record.getAuditNo()
+ "\n商户订单:" + payload.getString("orderId")
+ "\n金额:" + payload.getString("amount") + " " + payload.getString("currency")