提交冻结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

@@ -0,0 +1,75 @@
package com.ruoyi.system.rental;
import static com.ruoyi.system.rental.RentalValues.*;
import static org.junit.Assert.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.tron.trident.core.ApiWrapper;
/** 真实解码器配合可控RPC回执,验证代币、最小单位和确认边界,不访问公网。 */
public class RentalWithdrawChainTest {
private static final String TOKEN = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
private static final String RECEIVER = "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf";
private static final String HASH = String.join("", Collections.nCopies(64, "a"));
private static final String TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
private final ObjectMapper json = new ObjectMapper();
private long head = 10;
private String token = TOKEN;
private String result = "SUCCESS";
private long receiptTime = 1700000000000L;
private RentalWithdrawChain chain() {
RentalChain rpc = new RentalChain(json) {
@Override public JsonNode call(String network, String path, Map<String, Object> body) {
if (path.endsWith("gettransactioninfobyid")) {
return json.valueToTree(map("id", HASH, "blockNumber", 10, "blockTimeStamp", receiptTime,
"receipt", map("result", result), "log", Collections.singletonList(map(
"address", hex(token).substring(2), "topics", java.util.Arrays.asList(TOPIC, topic(TOKEN), topic(RECEIVER)),
"data", String.format("%064x", 30000000)))));
}
if (path.endsWith("gettransactionbyid")) {
return json.valueToTree(map("txID", HASH, "ret", Collections.singletonList(map("contractRet", result))));
}
if (path.endsWith("getblockbynum")) {
return json.valueToTree(map("blockID", HASH, "block_header", map("raw_data", map("number", 10, "timestamp", 1700000000000L))));
}
throw new AssertionError("未知RPC路径 " + path);
}
};
return new RentalWithdrawChain(rpc, null) {
@Override public String contract(String network) { return TOKEN; }
@Override public long confirmedHead(String network) { return head; }
};
}
@Test public void decodesExactUsdtUnitsAndBase58Addresses() {
List<Map<String, Object>> events = chain().events("NILE", HASH);
assertEquals(1, events.size());
assertEquals(money("30"), amount(events.get(0), "amount_usdt"));
assertEquals(RECEIVER, text(events.get(0), "to_address"));
assertEquals(TOKEN, text(events.get(0), "from_address"));
assertEquals(0, number(events.get(0), "log_index"));
}
@Test public void ignoresOtherTokenAndFailedReceipt() {
token = RECEIVER;
assertTrue(chain().events("NILE", HASH).isEmpty());
token = TOKEN; result = "REVERT";
assertTrue(chain().events("NILE", HASH).isEmpty());
}
@Test public void rejectsUnconfirmedAndInconsistentBlockEvidence() {
head = 9;
try { chain().events("NILE", HASH); fail("未确认不能到账"); } catch (IllegalArgumentException expected) { /* 保持冻结 */ }
head = 10; receiptTime++;
try { chain().events("NILE", HASH); fail("时间冲突不能到账"); } catch (IllegalArgumentException expected) { /* 保持冻结 */ }
}
private static String hex(String address) { return ApiWrapper.toHex(ApiWrapper.parseAddress(address)); }
private static String topic(String address) { return "000000000000000000000000" + hex(address).substring(2); }
}
@@ -0,0 +1,290 @@
package com.ruoyi.system.rental;
import static com.ruoyi.system.rental.RentalValues.*;
import static org.junit.Assert.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.system.mapper.TelegramAuditMapper;
import java.lang.reflect.Proxy;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.h2.jdbcx.JdbcDataSource;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
/** 真实H2事务、并发锁及持久游标;RPC/Telegram均隔离,不访问真实钱包或发送消息。 */
public class RentalWithdrawTest {
private static final String SENDER = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
private static final String RECEIVER = "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf";
private static final String HASH = String.join("", Collections.nCopies(64, "a"));
private final ObjectMapper json = new ObjectMapper();
private RentalStore store;
private RentalFunds funds;
private RentalWithdrawals service;
private FakeChain chain;
private StandardEnvironment environment;
private Map<String, Object> config;
private TransactionTemplate tx;
private long account;
private int telegramRecords;
private int telegramPushes;
@Before
public void setup() throws Exception {
JdbcDataSource source = new JdbcDataSource();
source.setURL("jdbc:h2:mem:" + UUID.randomUUID() + ";MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000");
JdbcTemplate jdbc = new JdbcTemplate(source);
store = new RentalStore(jdbc);
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_init.sql")), StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "").replace("CHARACTER SET ascii COLLATE ascii_bin", "")
.replaceAll("(?i)\\bJSON\\b", "LONGTEXT")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String sql : ddl.split(";")) { if (!sql.trim().isEmpty()) { jdbc.execute(sql); } }
DataSourceTransactionManager manager = new DataSourceTransactionManager(source);
tx = new TransactionTemplate(manager);
funds = new RentalFunds(store);
account = number(funds.account(10, "NILE"), "id");
long mainnet = number(funds.account(10, "MAINNET"), "id");
tx.execute(status -> {
for (long id : new long[] {account, mainnet}) {
funds.post(id, "INITIAL:" + id, "TOPUP", money("100"), ZERO, ZERO, ZERO, null, null, null, 0, null, "fixture");
}
return null;
});
config = map("rental.enabled", "true", "rental.withdraw.enabled", "true",
"rental.withdraw.nile.payout-addresses", SENDER, "rental.withdraw.mainnet.payout-addresses", SENDER);
environment = new StandardEnvironment();
environment.getPropertySources().addFirst(new MapPropertySource("test", config));
chain = new FakeChain();
TelegramAuditMapper telegram = (TelegramAuditMapper) Proxy.newProxyInstance(getClass().getClassLoader(),
new Class<?>[] {TelegramAuditMapper.class}, (proxy, method, args) -> {
if ("insertRecord".equals(method.getName())) { telegramRecords++; return 1; }
if ("insertPushTask".equals(method.getName())) { telegramPushes++; return 1; }
return null;
});
service = new RentalWithdrawals(store, funds, chain, environment, json, telegram, manager);
}
@Test
public void freezesOnceAndBlocksAnotherNetworkUntilRejection() {
Map<String, Object> order = create("first");
long id = number(order, "id");
assertEquals(id, number(create("first"), "id"));
assertEquals(money("70"), amount(store.get("account", account, false), "available_amount"));
assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount"));
rejected(() -> service.create(10, request("other", "MAINNET")));
Map<String, Object> conflict = request("first", "NILE"); conflict.put("amount", "31");
rejected(() -> service.create(10, conflict));
rejected(() -> service.review(id, true, 10, "BACKOFFICE", null, "self"));
service.review(id, false, 99, "BACKOFFICE", null, "拒绝测试");
assertEquals(money("100"), amount(store.get("account", account, false), "available_amount"));
assertEquals(ZERO, amount(store.get("account", account, false), "frozen_amount"));
rejected(() -> service.review(id, true, 99, "BACKOFFICE", null, "重复审核"));
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_RELEASE'").size());
assertNotNull(service.create(10, request("after-rejection", "MAINNET")));
assertEquals("MAINNET", text((Map<String, Object>) service.list(10, "NILE", "", 1, false).get("active"), "network"));
rejected(() -> service.detail(20, id, false));
}
@Test
public void manualAndAutoCompletionCompeteWithoutDoubleCharging() throws Exception {
Map<String, Object> order = approved("race");
long id = number(order, "id");
Map<String, Object> event = event(order, HASH, 0);
long eventId = service.record(event, "SCAN");
ExecutorService executor = Executors.newFixedThreadPool(2);
CountDownLatch start = new CountDownLatch(1);
try {
Future<?> manual = executor.submit(() -> { await(start); service.complete(id, eventId, "MANUAL", 99, "人工确认"); });
Future<?> auto = executor.submit(() -> { await(start); service.autoMatch(eventId); });
start.countDown(); manual.get(); auto.get();
} finally { executor.shutdownNow(); }
service.autoMatch(eventId);
assertEquals("COMPLETED", text(store.get("withdraw_order", id, false), "status"));
assertEquals(ZERO, amount(store.get("account", account, false), "frozen_amount"));
assertEquals(money("70"), amount(store.get("account", account, false), "available_amount"));
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_COMPLETE'").size());
assertTrue(Arrays.asList("MANUAL", "AUTO").contains(text(store.get("withdraw_order", id, false), "arrival_mode")));
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE withdraw_id=? AND event_type='WITHDRAW_COMPLETE'", id).size());
}
@Test
public void manualUnknownKeepsFrozenThenSameHashCanComplete() {
Map<String, Object> order = approved("manual");
long id = number(order, "id");
chain.fail = true;
Map<String, Object> request = map("transaction_id", HASH, "remark", "管理员已经在钱包付款");
assertEquals("VERIFYING", text(service.manual(id, request, 99), "status"));
assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount"));
chain.fail = false;
chain.events = Collections.singletonList(event(order, HASH, 0));
assertEquals("MANUAL", text(service.manual(id, request, 99), "arrival_mode"));
assertEquals("COMPLETED", text(service.manual(id, request, 99), "status"));
assertEquals(1, store.rows("SELECT id FROM rent_withdraw_transaction").size());
}
@Test
public void autoMatchingRejectsWrongTimeSenderAmountNetworkAndAmbiguousApplicants() {
Map<String, Object> order = approved("matching");
List<Map<String, Object>> wrong = new ArrayList<>();
Map<String, Object> early = event(order, HASH, 0); early.put("block_time", order.get("approved_at")); wrong.add(early);
Map<String, Object> sender = event(order, HASH, 1); sender.put("from_address", RECEIVER); wrong.add(sender);
Map<String, Object> amount = event(order, HASH, 2); amount.put("amount_usdt", money("29")); wrong.add(amount);
Map<String, Object> network = event(order, HASH, 3); network.put("network", "MAINNET"); wrong.add(network);
for (Map<String, Object> event : wrong) { service.autoMatch(service.record(event, "SCAN")); }
assertEquals("EXECUTING", text(store.get("withdraw_order", number(order, "id"), false), "status"));
assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount"));
long another = number(funds.account(20, "NILE"), "id");
tx.execute(status -> { funds.post(another, "INITIAL20", "TOPUP", money("100"), ZERO, ZERO, ZERO, null, null, null, 0, null, "fixture"); return null; });
long other = number(service.create(20, request("same-address", "NILE")), "id");
service.review(other, true, 99, "TELEGRAM", "123", "通过");
Map<String, Object> valid = event(order, HASH, 4); valid.put("block_time", now().plusSeconds(2));
long eventId = service.record(valid, "SCAN");
service.autoMatch(eventId);
assertEquals("AMBIGUOUS", text(store.get("withdraw_transaction", eventId, false), "match_status"));
assertEquals("MANUAL_REVIEW", text(store.get("withdraw_order", other, false), "status"));
service.complete(number(order, "id"), eventId, "MANUAL", 99, "核对实际付款记录确认来源");
rejected(() -> service.complete(other, eventId, "MANUAL", 99, "重复核销"));
}
@Test
public void twoConcurrentApplicationsHaveOnlyOneActiveAndOneHold() throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(2);
CountDownLatch start = new CountDownLatch(1);
try {
List<Future<Boolean>> results = new ArrayList<>();
for (String network : new String[] {"NILE", "MAINNET"}) {
results.add(executor.submit(() -> { await(start); try { service.create(10, request("parallel-" + network, network)); return true; } catch (IllegalArgumentException ex) { return false; } }));
}
start.countDown();
int success = 0; for (Future<Boolean> result : results) { if (result.get()) { success++; } }
assertEquals(1, success);
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_HOLD'").size());
assertEquals(1, store.rows("SELECT id FROM rent_withdraw_order WHERE active_user_id=10").size());
} finally { executor.shutdownNow(); }
}
@Test
public void telegramQueuePersistsOnceAndInvalidConfigurationCannotFreeze() {
config.put("telegram.enabled", "true");
create("telegram"); create("telegram");
assertEquals(1, telegramRecords); assertEquals(1, telegramPushes);
config.put("rental.withdraw.enabled", "false");
assertNotNull(create("telegram"));
rejected(() -> service.create(20, request("disabled", "NILE")));
assertEquals(1, store.rows("SELECT id FROM rent_withdraw_order").size());
}
@Test
public void scannerResumesAfterRpcFailureAndCompletesAutomatically() {
Map<String, Object> order = approved("scanner");
chain.events = Collections.singletonList(event(order, HASH, 0));
RentalWithdrawScanner scanner = new RentalWithdrawScanner(store, service, chain, environment);
chain.fail = true;
try { scanner.scan("NILE"); fail("RPC失败不能推进游标"); } catch (IllegalStateException expected) { /* 可恢复 */ }
assertEquals("EXECUTING", text(store.get("withdraw_order", number(order, "id"), false), "status"));
chain.fail = false;
scanner.scan("NILE");
assertEquals("COMPLETED", text(store.get("withdraw_order", number(order, "id"), false), "status"));
assertEquals("AUTO", text(store.get("withdraw_order", number(order, "id"), false), "arrival_mode"));
assertEquals(1, store.rows("SELECT id FROM rent_withdraw_transaction").size());
scanner.scan("NILE");
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_COMPLETE'").size());
}
@Test
public void duplicatePaymentsRequireManualSelectionWithoutUnfreezing() {
Map<String, Object> order = approved("duplicate-payments");
long first = service.record(event(order, HASH, 0), "SCAN");
service.record(event(order, HASH, 1), "SCAN");
service.autoMatch(first);
assertEquals("MANUAL_REVIEW", text(store.get("withdraw_order", number(order, "id"), false), "status"));
assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount"));
assertTrue(store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_COMPLETE'").isEmpty());
service.complete(number(order, "id"), first, "MANUAL", 99, "人工核对两笔付款后选择第一笔");
assertEquals(ZERO, amount(store.get("account", account, false), "frozen_amount"));
}
@Test
public void telegramApprovalUsesMappedReviewerAndRejectsDuplicateCallback() throws Exception {
store.execute("CREATE TABLE sys_user(user_id BIGINT,status VARCHAR(1),del_flag VARCHAR(1))");
store.execute("CREATE TABLE sys_user_role(user_id BIGINT,role_id BIGINT)");
store.execute("CREATE TABLE sys_role(role_id BIGINT,status VARCHAR(1),del_flag VARCHAR(1))");
store.execute("CREATE TABLE sys_role_menu(role_id BIGINT,menu_id BIGINT)");
store.execute("CREATE TABLE sys_menu(menu_id BIGINT,status VARCHAR(1),perms VARCHAR(100))");
store.execute("INSERT INTO sys_user VALUES(1,'0','0')");
config.put("rental.withdraw.telegram-reviewers", "123:1");
assertEquals(1, service.telegramReviewer("123"));
rejected(() -> service.telegramReviewer("456"));
Map<String, Object> order = create("telegram-routing");
com.ruoyi.system.domain.TelegramAuditRecord audit = new com.ruoyi.system.domain.TelegramAuditRecord();
audit.setAuditNo("test-audit"); audit.setBusinessType(RentalWithdrawals.TELEGRAM_TYPE);
audit.setBusinessId(String.valueOf(number(order, "id"))); audit.setAuditStatus("PENDING");
java.util.Set<Long> received = new java.util.HashSet<>();
TelegramAuditMapper mapper = (TelegramAuditMapper) Proxy.newProxyInstance(getClass().getClassLoader(),
new Class<?>[] {TelegramAuditMapper.class}, (proxy, method, args) -> {
if ("insertLog".equals(method.getName())) { return received.add((Long) args[1]) ? 1 : 0; }
if ("selectByAuditNo".equals(method.getName())) { return audit; }
if ("approve".equals(method.getName()) || "updateLogOutcome".equals(method.getName())) { return 1; }
return null;
});
com.ruoyi.system.service.TelegramAuditService telegram = new com.ruoyi.system.service.TelegramAuditService(
mapper, null, null, tx.getTransactionManager());
for (Map.Entry<String, Object> field : map("rentalWithdrawals", service, "allowedUserIds", "123", "botToken", "").entrySet()) {
java.lang.reflect.Field declared = telegram.getClass().getDeclaredField(field.getKey());
declared.setAccessible(true); declared.set(telegram, field.getValue());
}
com.alibaba.fastjson.JSONObject update = com.alibaba.fastjson.JSON.parseObject("{\"update_id\":1,\"callback_query\":{\"id\":\"callback\",\"from\":{\"id\":123},\"data\":\"ta:test-audit:A\"}}");
tx.execute(status -> { telegram.handleUpdate(update); return null; });
tx.execute(status -> { telegram.handleUpdate(update); return null; });
Map<String, Object> reviewed = store.get("withdraw_order", number(order, "id"), false);
assertEquals("EXECUTING", text(reviewed, "status"));
assertEquals("TELEGRAM", text(reviewed, "review_channel"));
assertEquals(1, number(reviewed, "reviewer_user_id"));
assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount"));
}
private Map<String, Object> create(String requestNo) { return service.create(10, request(requestNo, "NILE")); }
private Map<String, Object> request(String no, String network) { return map("network", network, "receiver_address", RECEIVER, "amount", "30", "client_request_no", no); }
private Map<String, Object> approved(String requestNo) {
long id = number(create(requestNo), "id");
service.review(id, true, 99, "BACKOFFICE", null, "审核通过");
return store.get("withdraw_order", id, false);
}
private Map<String, Object> event(Map<String, Object> order, String hash, int index) {
return map("network", "NILE", "transaction_id", hash, "log_index", index, "token_contract", SENDER,
"from_address", SENDER, "to_address", RECEIVER, "amount_units", 30000000, "amount_usdt", money("30"),
"block_number", 10, "block_hash", HASH, "block_time", LocalDateTime.ofInstant(time(order.get("approved_at")).plusSeconds(1), java.time.ZoneOffset.UTC));
}
private static void await(CountDownLatch latch) { try { latch.await(); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); throw new IllegalStateException(ex); } }
private static void rejected(Runnable action) { try { action.run(); fail("必须拒绝"); } catch (IllegalArgumentException expected) { /* 预期校验 */ } }
private final class FakeChain extends RentalWithdrawChain {
boolean fail;
List<Map<String, Object>> events = Collections.emptyList();
FakeChain() { super(null, null); }
@Override public long confirmedHead(String network) { if (fail) { throw new IllegalStateException("controlled RPC failure"); } return 10; }
@Override public JsonNode block(String network, long height) { return json.valueToTree(map("block_header", map("raw_data", map("number", height, "timestamp", System.currentTimeMillis() - (10 - height) * 3000 - 5000)))); }
@Override public JsonNode receipts(String network, long height) { return json.valueToTree(Collections.singletonList(map("id", HASH, "log", Collections.singletonList(map("fixture", true))))); }
@Override public boolean relevantLog(String network, JsonNode log, java.util.Set<String> senders) { return true; }
@Override public List<Map<String, Object>> events(String network, String hash) { if (fail) { throw new IllegalStateException("controlled unconfirmed"); } return events; }
}
}