959 lines
51 KiB
Java
959 lines
51 KiB
Java
package com.ruoyi.system.rental;
|
||
|
||
import static com.ruoyi.system.rental.RentalValues.*;
|
||
|
||
import org.springframework.stereotype.Service;
|
||
import org.springframework.transaction.support.TransactionTemplate;
|
||
|
||
import java.time.Instant;
|
||
import java.util.*;
|
||
import java.util.function.Supplier;
|
||
|
||
/** 持久任务状态机。数据库事务仅修改事实,所有RPC在事务外完成。 UNKNOWN保留三个占位和冻结资金;租约、断线、超时均不是未执行证据。 */
|
||
@Service
|
||
@lombok.extern.slf4j.Slf4j
|
||
public class RentalTasks {
|
||
@org.springframework.beans.factory.annotation.Value("${rental.delivery.verification-grace-seconds:180}")
|
||
private long verificationGraceSeconds = 180L;
|
||
@org.springframework.beans.factory.annotation.Autowired(required = false)
|
||
private org.springframework.context.ApplicationEventPublisher deliveryEvents;
|
||
private final RentalStore store;
|
||
private final RentalChain chain;
|
||
private final RentalIdentity identity;
|
||
private final RentalOrders orders;
|
||
private final RentalFunds funds;
|
||
private final TransactionTemplate transaction;
|
||
|
||
public RentalTasks(
|
||
RentalStore store,
|
||
RentalChain chain,
|
||
RentalIdentity identity,
|
||
RentalOrders orders,
|
||
RentalFunds funds,
|
||
org.springframework.transaction.PlatformTransactionManager manager) {
|
||
this.store = store;
|
||
this.chain = chain;
|
||
this.identity = identity;
|
||
this.orders = orders;
|
||
this.funds = funds;
|
||
this.transaction = new TransactionTemplate(manager);
|
||
}
|
||
|
||
public <T> T tx(Supplier<T> action) {
|
||
return transaction.execute(status -> action.get());
|
||
}
|
||
|
||
public void refresh(long id) {
|
||
Map<String, Object> previous = store.get("wallet", id, false);
|
||
Map<String, Object> snapshot =
|
||
chain.snapshot(text(previous, "network"), text(previous, "address"));
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> current = store.get("wallet", id, true);
|
||
require(
|
||
number(previous, "version") == number(current, "version")
|
||
&& number(snapshot, "snapshot_block_height")
|
||
>= number(current, "snapshot_min_block_height")
|
||
&& (current.get("snapshot_block_height") == null
|
||
|| number(snapshot, "snapshot_block_height")
|
||
>= number(current, "snapshot_block_height")),
|
||
"快照已过时,丢弃并重新查询");
|
||
store.update("wallet", id, snapshot);
|
||
return null;
|
||
});
|
||
}
|
||
|
||
public void dispatch(long orderId) {
|
||
Map<String, Object> initial = store.get("order", orderId, false);
|
||
if (!"WAITING".equals(text(initial, "status"))) {
|
||
return;
|
||
}
|
||
if (!time(initial.get("dispatch_deadline")).isAfter(Instant.now())) {
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> row = store.get("order", orderId, true);
|
||
if ("WAITING".equals(text(row, "status"))) {
|
||
require(
|
||
store.one(
|
||
"SELECT id FROM rent_task WHERE order_id=? AND"
|
||
+ " active_slot=1",
|
||
orderId)
|
||
== null,
|
||
"在途任务不可超时释放");
|
||
funds.release(row);
|
||
store.update("order", orderId, map("status", "CANCELLED"));
|
||
orders.webhook(row, "CANCELLED", "ORDER:" + orderId + ":CANCELLED");
|
||
log.info("租赁未派单超时释放 orderId={} orderType={} releasedUsdt={}",
|
||
orderId, row.get("order_type"), row.get("sale_amount"));
|
||
}
|
||
return null;
|
||
});
|
||
return;
|
||
}
|
||
List<Map<String, Object>> candidates =
|
||
store.rows(
|
||
"SELECT w.* FROM rent_wallet w JOIN rent_node n ON n.id=w.node_id WHERE"
|
||
+ " w.status='ACTIVE' AND w.ownership_verified_at IS NOT NULL AND"
|
||
+ " w.network=? AND w.snapshot_expires_at>? AND n.status='ACTIVE' AND"
|
||
+ " n.connection_status='ONLINE' AND n.heartbeat_expires_at>? ORDER BY"
|
||
+ " w.id LIMIT 20",
|
||
text(initial, "network"),
|
||
now(),
|
||
now());
|
||
for (Map<String, Object> candidate : candidates) {
|
||
String type = text(initial, "resource_type"), owner = text(candidate, "address");
|
||
if (owner.equals(text(initial, "receiver_address"))) {
|
||
continue;
|
||
}
|
||
if (RentalOnchain.isOrder(initial)) {
|
||
if (dispatchOnchain(initial, candidate)) {
|
||
return;
|
||
}
|
||
continue;
|
||
}
|
||
if (chain.relation(
|
||
text(initial, "network"),
|
||
owner,
|
||
text(initial, "receiver_address"),
|
||
type)
|
||
!= 0) {
|
||
continue;
|
||
}
|
||
chain.prepareHistory(text(initial, "network"), owner,
|
||
text(initial, "receiver_address"), type);
|
||
Boolean assigned =
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> order = store.get("order", orderId, true);
|
||
if (!"WAITING".equals(text(order, "status"))
|
||
|| !time(order.get("dispatch_deadline"))
|
||
.isAfter(Instant.now())) {
|
||
return false;
|
||
}
|
||
Map<String, Object> wallet =
|
||
store.get("wallet", number(candidate, "id"), true);
|
||
if (number(wallet, "version") != number(candidate, "version")) {
|
||
return false;
|
||
}
|
||
Map<String, Object> node =
|
||
store.get("node", number(wallet, "node_id"), true);
|
||
String prefix = resource(type).toLowerCase(Locale.ROOT);
|
||
if (!"ACTIVE".equals(text(node, "status"))
|
||
|| !"ONLINE".equals(text(node, "connection_status"))
|
||
|| node.get("heartbeat_expires_at") == null
|
||
|| !time(node.get("heartbeat_expires_at"))
|
||
.isAfter(Instant.now())
|
||
|| number(wallet, prefix + "_enabled") != 1
|
||
|| wallet.get("snapshot_expires_at") == null
|
||
|| !time(wallet.get("snapshot_expires_at"))
|
||
.isAfter(Instant.now())
|
||
|| number(wallet, "snapshot_block_height")
|
||
< number(wallet, "snapshot_min_block_height")) {
|
||
return false;
|
||
}
|
||
if (store.one(
|
||
"SELECT id FROM rent_task WHERE wallet_id=?"
|
||
+ " AND resource_type=? AND"
|
||
+ " wallet_execution_slot=1",
|
||
wallet.get("id"),
|
||
type)
|
||
!= null
|
||
|| store.one(
|
||
"SELECT id FROM rent_order WHERE"
|
||
+ " wallet_id=? AND receiver_address=?"
|
||
+ " AND resource_type=? AND"
|
||
+ " relation_slot=1",
|
||
wallet.get("id"),
|
||
order.get("receiver_address"),
|
||
type)
|
||
!= null) {
|
||
return false;
|
||
}
|
||
long limit = number(wallet, "total_" + prefix + "_limit"),
|
||
weight = number(wallet, "total_" + prefix + "_weight");
|
||
long sun =
|
||
principal(
|
||
number(order, "target_resource_quantity"),
|
||
limit,
|
||
weight);
|
||
long available =
|
||
Math.subtractExact(
|
||
Math.subtractExact(
|
||
number(wallet, prefix + "_delegatable_sun"),
|
||
number(wallet, prefix + "_reserved_sun")),
|
||
number(wallet, prefix + "_retain_sun"));
|
||
if (sun > available) {
|
||
return false;
|
||
}
|
||
Map<String, Object> supplier =
|
||
funds.account(
|
||
number(node, "user_id"), text(order, "network"));
|
||
require("ACTIVE".equals(text(supplier, "status")), "供应商资金账户冻结");
|
||
store.update(
|
||
"wallet",
|
||
number(wallet, "id"),
|
||
map(
|
||
prefix + "_reserved_sun",
|
||
Math.addExact(
|
||
number(wallet, prefix + "_reserved_sun"),
|
||
sun)));
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map(
|
||
"status",
|
||
"EXECUTING",
|
||
"wallet_id",
|
||
wallet.get("id"),
|
||
"supplier_user_id",
|
||
node.get("user_id"),
|
||
"supplier_account_id",
|
||
supplier.get("id"),
|
||
"relation_slot",
|
||
1));
|
||
createTask(order, wallet, "DELEGATE", sun, limit, weight, null);
|
||
store.event(
|
||
"ORDER", orderId, "DISPATCH", 0, "预留对应资源SUN并取得地址对和执行占位");
|
||
return true;
|
||
});
|
||
if (Boolean.TRUE.equals(assigned)) {
|
||
log.info("租赁订单已分配 orderId={} nodeId={} orderAgeMs={}", orderId,
|
||
candidate.get("node_id"), System.currentTimeMillis()
|
||
- time(initial.get("created_at")).toEpochMilli());
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
/** TRX 任务独立占用钱包 TRX 执行槽,不占用质押资源,也不建立委托地址对及历史资源基线。 */
|
||
private boolean dispatchOnchain(Map<String, Object> initial, Map<String, Object> candidate) {
|
||
Map<String, Object> advertised = store.get("node", number(candidate, "node_id"), false);
|
||
if (number(advertised, "transfer_enabled") != 1) {
|
||
log.debug("地址上链候选未授权转账 orderId={} nodeId={}", initial.get("id"), advertised.get("id"));
|
||
return false;
|
||
}
|
||
Map<String, Object> price;
|
||
try {
|
||
price = new com.fasterxml.jackson.databind.ObjectMapper().readValue(text(initial, "package_snapshot"), Map.class);
|
||
} catch (Exception ex) {
|
||
throw new IllegalArgumentException("地址上链费用快照损坏");
|
||
}
|
||
// 仅作候选过滤,Agent 在签名前仍需重新检查余额、激活成本、费率及本地留存。
|
||
long balance = chain.call(text(initial, "network"), "/wallet/getaccount",
|
||
map("address", text(candidate, "address"), "visible", true)).path("balance").asLong();
|
||
if (balance < Math.addExact(RentalOnchain.TRANSFER_SUN, number(price, "fee_limit_sun"))) {
|
||
log.debug("地址上链候选余额不足 orderId={} walletId={} balanceSun={}", initial.get("id"), candidate.get("id"), balance);
|
||
return false;
|
||
}
|
||
return Boolean.TRUE.equals(tx(() -> {
|
||
Map<String, Object> order = store.get("order", number(initial, "id"), true);
|
||
Map<String, Object> wallet = store.get("wallet", number(candidate, "id"), true);
|
||
Map<String, Object> node = store.get("node", number(wallet, "node_id"), true);
|
||
if (!"WAITING".equals(text(order, "status")) || !time(order.get("dispatch_deadline")).isAfter(Instant.now())
|
||
|| !"ACTIVE".equals(text(wallet, "status")) || !"ACTIVE".equals(text(node, "status"))
|
||
|| number(node, "transfer_enabled") != 1 || !"ONLINE".equals(text(node, "connection_status"))
|
||
|| !time(node.get("heartbeat_expires_at")).isAfter(Instant.now())
|
||
|| store.one("SELECT id FROM rent_task WHERE wallet_id=? AND resource_type='TRX' AND wallet_execution_slot=1",
|
||
wallet.get("id")) != null) {
|
||
return false;
|
||
}
|
||
Map<String, Object> supplier = funds.account(number(node, "user_id"), text(order, "network"));
|
||
require("ACTIVE".equals(text(supplier, "status")), "供应商资金账户冻结");
|
||
store.update("order", number(order, "id"), map("status", "EXECUTING", "wallet_id", wallet.get("id"),
|
||
"supplier_user_id", node.get("user_id"), "supplier_account_id", supplier.get("id")));
|
||
createTask(order, wallet, RentalOnchain.TASK_TYPE, RentalOnchain.TRANSFER_SUN, 0, 0, null);
|
||
store.event("ORDER", number(order, "id"), "DISPATCH", 0, "固定1TRX转账,供应商获得本金补偿及服务费");
|
||
log.info("地址上链派单 orderId={} walletId={} nodeId={} transferSun={}", order.get("id"), wallet.get("id"), node.get("id"), RentalOnchain.TRANSFER_SUN);
|
||
return true;
|
||
}));
|
||
}
|
||
|
||
private void createTask(
|
||
Map<String, Object> order,
|
||
Map<String, Object> wallet,
|
||
String type,
|
||
long sun,
|
||
long limit,
|
||
long weight,
|
||
Map<String, Object> source) {
|
||
long nodeId = number(wallet, "node_id"), orderId = number(order, "id");
|
||
Map<String, Object> credential =
|
||
store.one(
|
||
"SELECT * FROM rent_credential WHERE owner_type='NODE' AND owner_id=? AND"
|
||
+ " status='ACTIVE' AND (expires_at IS NULL OR expires_at>?) ORDER BY"
|
||
+ " id DESC LIMIT 1",
|
||
nodeId,
|
||
now());
|
||
require(credential != null, "节点缺少有效凭证");
|
||
Map<String, Object> last =
|
||
store.one(
|
||
"SELECT COALESCE(MAX(attempt_no),0) AS attempt FROM rent_task WHERE"
|
||
+ " order_id=? AND task_type=?",
|
||
orderId,
|
||
type);
|
||
long attempt = number(last, "attempt") + 1;
|
||
String taskNo = id("RT"), nonce = RentalCrypto.random();
|
||
long signed = System.currentTimeMillis();
|
||
java.time.LocalDateTime deadline =
|
||
!"RECLAIM".equals(type)
|
||
? java.time.LocalDateTime.ofInstant(
|
||
time(order.get("dispatch_deadline")), java.time.ZoneOffset.UTC)
|
||
: after(300);
|
||
Map<String, Object> product;
|
||
try {
|
||
product =
|
||
new com.fasterxml.jackson.databind.ObjectMapper()
|
||
.readValue(text(order, "package_snapshot"), Map.class);
|
||
} catch (Exception ex) {
|
||
throw new IllegalArgumentException("订单规则快照损坏");
|
||
}
|
||
long fee = number(product, "fee_limit_sun");
|
||
Map<String, Object> intent =
|
||
map(
|
||
"protocol",
|
||
"RENT_TASK_V2",
|
||
"task_no",
|
||
taskNo,
|
||
"node_id",
|
||
Long.toString(nodeId),
|
||
"network",
|
||
text(order, "network"),
|
||
"task_type",
|
||
type,
|
||
"resource_type",
|
||
text(order, "resource_type"),
|
||
"resource_quantity",
|
||
text(order, "resource_quantity"),
|
||
"target_resource_quantity",
|
||
text(order, "target_resource_quantity"),
|
||
"owner",
|
||
text(wallet, "address"),
|
||
"receiver",
|
||
text(order, "receiver_address"),
|
||
"delegate_sun",
|
||
Long.toString(sun),
|
||
"total_limit",
|
||
Long.toString(limit),
|
||
"total_weight",
|
||
Long.toString(weight),
|
||
"baseline_sun",
|
||
!"RECLAIM".equals(type) ? "0" : Long.toString(sun),
|
||
"conversion_block_height",
|
||
text(wallet, "snapshot_block_height"),
|
||
"delegate_lock",
|
||
false,
|
||
"fee_limit_sun",
|
||
Long.toString(fee),
|
||
"deadline",
|
||
Long.toString(deadline.toInstant(java.time.ZoneOffset.UTC).toEpochMilli()),
|
||
"source_tx_id",
|
||
source == null ? "" : text(source, "tx_id"));
|
||
// MySQL JSON会规范化键顺序/空格;签名使用排序后的紧凑JSON,投递时按同样规则重建。
|
||
String body = orders.encode(new TreeMap<>(intent)), key = text(credential, "api_key");
|
||
store.insert(
|
||
"task",
|
||
map(
|
||
"task_no",
|
||
taskNo,
|
||
"order_id",
|
||
orderId,
|
||
"wallet_id",
|
||
wallet.get("id"),
|
||
"node_id",
|
||
nodeId,
|
||
"network",
|
||
text(order, "network"),
|
||
"source_transaction_id",
|
||
source == null ? null : source.get("id"),
|
||
"task_type",
|
||
type,
|
||
"resource_type",
|
||
text(order, "resource_type"),
|
||
"resource_quantity",
|
||
order.get("resource_quantity"),
|
||
"target_resource_quantity",
|
||
order.get("target_resource_quantity"),
|
||
"conversion_total_limit",
|
||
limit,
|
||
"conversion_total_weight",
|
||
weight,
|
||
"conversion_block_height",
|
||
wallet.get("snapshot_block_height"),
|
||
"conversion_at",
|
||
now(),
|
||
"estimated_resource_quantity",
|
||
RentalOnchain.TASK_TYPE.equals(type) ? 0 : quantity(sun, limit, weight),
|
||
"attempt_no",
|
||
attempt,
|
||
"active_slot",
|
||
1,
|
||
"wallet_execution_slot",
|
||
1,
|
||
"delegate_sun",
|
||
sun,
|
||
"fee_limit_sun",
|
||
fee,
|
||
"credential_id",
|
||
credential.get("id"),
|
||
"nonce",
|
||
nonce,
|
||
"signed_at",
|
||
now(),
|
||
"deadline",
|
||
deadline,
|
||
"intent",
|
||
body,
|
||
"signature",
|
||
RentalCrypto.sign(
|
||
identity.secret(credential),
|
||
"TASK",
|
||
key,
|
||
signed,
|
||
nonce,
|
||
"PUSH",
|
||
"/node/v1/task",
|
||
body),
|
||
"status",
|
||
"PENDING",
|
||
"reservation_status",
|
||
"DELEGATE".equals(type) ? "HELD" : "NONE",
|
||
"delivery_message_id",
|
||
id("MSG"),
|
||
"next_check_at",
|
||
now()));
|
||
// signed_at参与HMAC必须与毫秒值完全一致,不能用第二次now()。
|
||
store.execute(
|
||
"UPDATE rent_task SET signed_at=? WHERE task_no=?",
|
||
java.time.LocalDateTime.ofInstant(
|
||
Instant.ofEpochMilli(signed), java.time.ZoneOffset.UTC),
|
||
taskNo);
|
||
RentalDeliveryEvents.afterCommit(deliveryEvents, false, nodeId);
|
||
}
|
||
|
||
public void reclaim(long orderId) {
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> order = store.get("order", orderId, true);
|
||
if (!Arrays.asList("WAITING", "MANUAL_REVIEW")
|
||
.contains(text(order, "reclaim_status"))
|
||
|| order.get("next_reclaim_at") == null
|
||
|| time(order.get("next_reclaim_at")).isAfter(Instant.now())) {
|
||
return null;
|
||
}
|
||
Map<String, Object> source =
|
||
store.one(
|
||
"SELECT x.* FROM rent_transaction x JOIN rent_task t ON"
|
||
+ " t.id=x.task_id WHERE t.order_id=? AND"
|
||
+ " t.task_type='DELEGATE' AND x.status='CONFIRMED' ORDER"
|
||
+ " BY x.id LIMIT 1",
|
||
orderId);
|
||
require(source != null, "缺少原确认委托");
|
||
Map<String, Object> wallet =
|
||
store.get("wallet", number(order, "wallet_id"), true);
|
||
if (store.one(
|
||
"SELECT id FROM rent_task WHERE wallet_id=? AND resource_type=?"
|
||
+ " AND wallet_execution_slot=1",
|
||
wallet.get("id"),
|
||
order.get("resource_type"))
|
||
!= null) {
|
||
return null;
|
||
}
|
||
if (store.one(
|
||
"SELECT id FROM rent_task WHERE order_id=? AND"
|
||
+ " task_type='RECLAIM' AND active_slot=1",
|
||
orderId)
|
||
!= null) {
|
||
return null;
|
||
}
|
||
Map<String, Object> original =
|
||
store.get("task", number(source, "task_id"), false);
|
||
createTask(
|
||
order,
|
||
wallet,
|
||
"RECLAIM",
|
||
number(source, "amount_sun"),
|
||
number(original, "conversion_total_limit"),
|
||
number(original, "conversion_total_weight"),
|
||
source);
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map("reclaim_status", "RUNNING", "next_reclaim_at", after(30)));
|
||
return null;
|
||
});
|
||
}
|
||
|
||
/** 来自当前认证会话的事件先持久去重;节点自报成功只记录线索,不扣款。 */
|
||
public void report(long nodeId, Map<String, Object> report) {
|
||
String taskNo = input(report, "task_no", 64);
|
||
String eventId = input(report, "event_id", 40);
|
||
String kind = input(report, "state", 24);
|
||
require(eventId.matches("[A-Za-z0-9_-]+"), "事件编号非法");
|
||
Map<String, Object> initial =
|
||
store.one("SELECT * FROM rent_task WHERE task_no=? AND node_id=?", taskNo, nodeId);
|
||
require(initial != null, "任务不属于节点");
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> order =
|
||
store.get("order", number(initial, "order_id"), true);
|
||
Map<String, Object> wallet =
|
||
store.get("wallet", number(initial, "wallet_id"), true);
|
||
Map<String, Object> task = store.get("task", number(initial, "id"), true);
|
||
String event = "NODE:" + nodeId + ":" + eventId;
|
||
if (store.one("SELECT id FROM rent_event WHERE event_no=?", event) != null) {
|
||
return null;
|
||
}
|
||
long taskId = number(task, "id");
|
||
if ("ACK".equals(kind)) {
|
||
store.update("task", taskId, map("delivery_acked_at", now()));
|
||
} else if ("ACCEPTED".equals(kind) && "PENDING".equals(text(task, "status"))) {
|
||
store.update(
|
||
"task", taskId, map("status", "ACCEPTED", "accepted_at", now()));
|
||
} else if ("REJECTED".equals(kind)) {
|
||
require(
|
||
store.one("SELECT id FROM rent_transaction WHERE task_id=?", taskId)
|
||
== null
|
||
&& Arrays.asList("PENDING", "ACCEPTED", "UNKNOWN")
|
||
.contains(text(task, "status")),
|
||
"已存在广播线索,不能按未执行释放");
|
||
fail(task, order, wallet, "REJECTED");
|
||
} else if (Arrays.asList("BUILT", "BROADCASTED", "UNKNOWN", "RESULT")
|
||
.contains(kind)) {
|
||
require(
|
||
!Arrays.asList("REJECTED", "FAILED").contains(text(task, "status")),
|
||
"明确终结任务不可重新报告执行,应隔离核对");
|
||
String txId = text(report, "tx_id");
|
||
if (!txId.isEmpty()) {
|
||
require(txId.matches("[0-9a-fA-F]{64}"), "交易哈希无效");
|
||
Map<String, Object> existing =
|
||
store.one(
|
||
"SELECT * FROM rent_transaction WHERE task_id=?",
|
||
taskId);
|
||
if (existing != null) {
|
||
require(
|
||
txId.equalsIgnoreCase(text(existing, "tx_id")),
|
||
"一任务只能有一笔原交易");
|
||
} else {
|
||
store.insert(
|
||
"transaction",
|
||
map(
|
||
"task_id",
|
||
taskId,
|
||
"network",
|
||
text(task, "network"),
|
||
"tx_id",
|
||
txId.toLowerCase(Locale.ROOT),
|
||
"owner_address",
|
||
text(wallet, "address"),
|
||
"receiver_address",
|
||
text(order, "receiver_address"),
|
||
"transaction_type",
|
||
text(task, "task_type"),
|
||
"resource_type",
|
||
text(task, "resource_type"),
|
||
"amount_sun",
|
||
task.get("delegate_sun"),
|
||
"baseline_sun",
|
||
!"RECLAIM".equals(text(task, "task_type"))
|
||
? 0
|
||
: task.get("delegate_sun"),
|
||
"status",
|
||
"REPORTED",
|
||
"next_check_at",
|
||
now()));
|
||
}
|
||
}
|
||
if (!"VERIFIED".equals(text(task, "status"))) {
|
||
store.update(
|
||
"task",
|
||
taskId,
|
||
map(
|
||
"status",
|
||
"UNKNOWN".equals(kind) ? "UNKNOWN" : "BROADCASTED",
|
||
"next_check_at",
|
||
now()));
|
||
if (!"RECLAIM".equals(text(task, "task_type"))) {
|
||
store.update(
|
||
"order", number(order, "id"), map("status", "VERIFYING"));
|
||
}
|
||
}
|
||
} else if (!Arrays.asList("VERIFIED", "FAILED", "REJECTED")
|
||
.contains(text(task, "status"))) {
|
||
throw new IllegalArgumentException("未知节点事件");
|
||
}
|
||
store.insert(
|
||
"event",
|
||
map(
|
||
"event_no",
|
||
event,
|
||
"object_type",
|
||
"TASK",
|
||
"object_id",
|
||
taskId,
|
||
"action",
|
||
kind,
|
||
"actor_user_id",
|
||
0,
|
||
"node_id",
|
||
nodeId,
|
||
"reason",
|
||
"已认证节点事件,成功仍须独立链上核验"));
|
||
log.info("节点任务事件 nodeId={} taskId={} orderId={} taskType={} event={} txPresent={}",
|
||
nodeId, taskId, order.get("id"), task.get("task_type"), kind, !text(report, "tx_id").isEmpty());
|
||
return null;
|
||
});
|
||
}
|
||
|
||
public void verify(long taskId) {
|
||
Map<String, Object> task = store.get("task", taskId, false);
|
||
Map<String, Object> record =
|
||
store.one("SELECT * FROM rent_transaction WHERE task_id=?", taskId);
|
||
if (record == null
|
||
|| "CONFIRMED".equals(text(record, "status"))
|
||
|| "FAILED".equals(text(record, "status"))) {
|
||
return;
|
||
}
|
||
Map<String, Object> proof =
|
||
chain.verify(
|
||
task,
|
||
text(record, "tx_id"),
|
||
text(record, "owner_address"),
|
||
text(record, "receiver_address"));
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> order = store.get("order", number(task, "order_id"), true);
|
||
Map<String, Object> wallet =
|
||
store.get("wallet", number(task, "wallet_id"), true);
|
||
Map<String, Object> current = store.get("task", taskId, true);
|
||
Map<String, Object> currentTx =
|
||
store.get("transaction", number(record, "id"), true);
|
||
if ("CONFIRMED".equals(text(currentTx, "status"))
|
||
|| "FAILED".equals(text(currentTx, "status"))) {
|
||
return null;
|
||
}
|
||
if ("FAILED".equals(text(proof, "status"))) {
|
||
store.update("transaction", number(record, "id"), map("status", "FAILED"));
|
||
fail(current, order, wallet, "FAILED");
|
||
return null;
|
||
}
|
||
Map<String, Object> fields = new LinkedHashMap<>(proof);
|
||
fields.remove("delivery_proven");
|
||
fields.remove("history_proof");
|
||
fields.remove("delivery_evidence_gap");
|
||
fields.put("evidence", orders.encode(proof));
|
||
fields.put("confirmed_at", now());
|
||
store.update("transaction", number(record, "id"), fields);
|
||
if (RentalOnchain.TASK_TYPE.equals(text(current, "task_type"))) {
|
||
// 原生转账不存在租期与回收;确认到账后仅扣一次冻结款并生成供应商待结算收入。
|
||
funds.charge(order);
|
||
store.update("task", taskId, map("status", "VERIFIED", "wallet_execution_slot", null));
|
||
store.update("order", number(order, "id"), map("status", "SUCCESS", "reclaim_status", "NOT_REQUIRED",
|
||
"service_started_at", proof.get("block_time"), "error_code", null));
|
||
orders.webhook(order, "SUCCESS", "ORDER:" + order.get("id") + ":SUCCESS");
|
||
store.event("TASK", taskId, "CHAIN_CONFIRMED", 0, "独立核验固定1TRX转账并扣款,无回收任务");
|
||
log.info("地址上链核验扣款完成 orderId={} taskId={} network={} txId={} blockHeight={} chargedUsdt={}",
|
||
order.get("id"), taskId, task.get("network"), record.get("tx_id"), proof.get("block_height"), order.get("sale_amount"));
|
||
return null;
|
||
}
|
||
boolean delegate = "DELEGATE".equals(text(current, "task_type"));
|
||
String prefix = text(current, "resource_type").toLowerCase(Locale.ROOT);
|
||
Map<String, Object> barrier =
|
||
map(
|
||
"snapshot_min_block_height",
|
||
Math.max(
|
||
number(wallet, "snapshot_min_block_height"),
|
||
number(proof, "block_height")),
|
||
"snapshot_expires_at",
|
||
null);
|
||
if (delegate && "HELD".equals(text(current, "reservation_status"))) {
|
||
long remaining =
|
||
Math.subtractExact(
|
||
number(wallet, prefix + "_reserved_sun"),
|
||
number(current, "delegate_sun"));
|
||
require(remaining >= 0, "预留账实不一致");
|
||
barrier.put(prefix + "_reserved_sun", remaining);
|
||
}
|
||
store.update("wallet", number(wallet, "id"), barrier);
|
||
store.update(
|
||
"task",
|
||
taskId,
|
||
map(
|
||
"status",
|
||
"VERIFIED",
|
||
"wallet_execution_slot",
|
||
null,
|
||
"reservation_status",
|
||
delegate ? "COMMITTED" : "NONE"));
|
||
long orderId = number(order, "id");
|
||
if (delegate) {
|
||
Instant start = time(proof.get("block_time")),
|
||
expires = start.plusSeconds(number(order, "duration_seconds"));
|
||
Instant checkedAt = Instant.now();
|
||
// 在同一次判断中固定核验时间;记录所有未满足项,避免日志与状态跨租期边界不一致。
|
||
String reviewReason = RentalDeliveryDiagnostics.explain(
|
||
Boolean.TRUE.equals(proof.get("delivery_proven")),
|
||
proof.get("verified_resource_quantity") == null ? null
|
||
: number(proof, "verified_resource_quantity"),
|
||
number(order, "target_resource_quantity"), expires, checkedAt,
|
||
verificationGraceSeconds);
|
||
String gap = RentalDeliveryDiagnostics.evidenceGap(text(proof, "delivery_evidence_gap"));
|
||
if (!gap.isEmpty() && !Boolean.TRUE.equals(proof.get("delivery_proven"))) {
|
||
reviewReason += ";" + gap;
|
||
}
|
||
boolean delivered = reviewReason.isEmpty();
|
||
if (delivered) {
|
||
funds.charge(order);
|
||
}
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map(
|
||
"status",
|
||
delivered ? "SUCCESS" : "MANUAL_REVIEW",
|
||
"service_started_at",
|
||
proof.get("block_time"),
|
||
"service_expires_at",
|
||
java.time.LocalDateTime.ofInstant(
|
||
expires, java.time.ZoneOffset.UTC),
|
||
"reclaim_status",
|
||
"WAITING",
|
||
"next_reclaim_at",
|
||
java.time.LocalDateTime.ofInstant(
|
||
expires, java.time.ZoneOffset.UTC),
|
||
"error_code",
|
||
delivered ? null : "DELIVERY_EVIDENCE_REVIEW"));
|
||
if (delivered) {
|
||
orders.webhook(order, "SUCCESS", "ORDER:" + orderId + ":SUCCESS");
|
||
} else {
|
||
// 与人工核对状态同事务保存,查询端无需推测或重新查询链上即可展示当时的原因。
|
||
store.event("ORDER", orderId, "DELIVERY_REVIEW", 0, reviewReason);
|
||
log.warn("租赁履约未通过 orderId={} taskId={} txId={} historyProven={}"
|
||
+ " verifiedQuantity={} targetQuantity={} reason={}",
|
||
orderId, taskId, record.get("tx_id"), proof.get("delivery_proven"),
|
||
proof.get("verified_resource_quantity"), order.get("target_resource_quantity"),
|
||
reviewReason);
|
||
}
|
||
} else {
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map("reclaim_status", "RECOVERING", "next_reclaim_at", after(15)));
|
||
}
|
||
store.event("TASK", taskId, "CHAIN_CONFIRMED", 0, "独立核验并同事务提升快照屏障,禁止旧快照重新出租");
|
||
return null;
|
||
});
|
||
}
|
||
|
||
private void fail(
|
||
Map<String, Object> task,
|
||
Map<String, Object> order,
|
||
Map<String, Object> wallet,
|
||
String state) {
|
||
boolean delegate = "DELEGATE".equals(text(task, "task_type"));
|
||
long taskId = number(task, "id"), orderId = number(order, "id");
|
||
if (delegate && "HELD".equals(text(task, "reservation_status"))) {
|
||
String column = text(task, "resource_type").toLowerCase(Locale.ROOT) + "_reserved_sun";
|
||
long remaining =
|
||
Math.subtractExact(number(wallet, column), number(task, "delegate_sun"));
|
||
require(remaining >= 0, "资源预留冲突");
|
||
store.update("wallet", number(wallet, "id"), map(column, remaining));
|
||
}
|
||
store.update(
|
||
"task",
|
||
taskId,
|
||
map(
|
||
"status",
|
||
state,
|
||
"active_slot",
|
||
null,
|
||
"wallet_execution_slot",
|
||
null,
|
||
"reservation_status",
|
||
delegate ? "RELEASED" : "NONE"));
|
||
if (delegate || RentalOnchain.TASK_TYPE.equals(text(task, "task_type"))) {
|
||
boolean retry =
|
||
number(task, "attempt_no") < 4
|
||
&& time(order.get("dispatch_deadline")).isAfter(Instant.now());
|
||
if (!retry) {
|
||
funds.release(order);
|
||
orders.webhook(order, "FAILED", "ORDER:" + orderId + ":FAILED");
|
||
}
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map(
|
||
"status",
|
||
retry ? "WAITING" : "FAILED",
|
||
"relation_slot",
|
||
null,
|
||
"wallet_id",
|
||
null));
|
||
} else {
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map("reclaim_status", "WAITING", "next_reclaim_at", after(60)));
|
||
}
|
||
store.event("TASK", taskId, "SAFE_FAILURE", 0, "明确拒绝未构建或链上确认失败;未知不走本分支");
|
||
log.warn("任务明确失败 taskId={} orderId={} taskType={} state={} attempt={},仅明确失败允许释放或重派",
|
||
taskId, orderId, task.get("task_type"), state, task.get("attempt_no"));
|
||
}
|
||
|
||
public void recoverResource(long orderId) {
|
||
Map<String, Object> order = store.get("order", orderId, false);
|
||
if (!"RECOVERING".equals(text(order, "reclaim_status"))) {
|
||
return;
|
||
}
|
||
Map<String, Object> wallet = store.get("wallet", number(order, "wallet_id"), false);
|
||
Map<String, Object> snapshot =
|
||
chain.snapshot(text(wallet, "network"), text(wallet, "address"));
|
||
if (chain.relation(
|
||
text(wallet, "network"),
|
||
text(wallet, "address"),
|
||
text(order, "receiver_address"),
|
||
text(order, "resource_type"))
|
||
!= 0) {
|
||
return;
|
||
}
|
||
// 可委托本金>0不代表本单资源已恢复。保守要求原本金可再次委托,减去本地占用和留存。
|
||
Map<String, Object> source =
|
||
store.one(
|
||
"SELECT x.* FROM rent_transaction x JOIN rent_task t ON t.id=x.task_id"
|
||
+ " WHERE t.order_id=? AND t.task_type='DELEGATE' AND"
|
||
+ " x.status='CONFIRMED'",
|
||
orderId);
|
||
String prefix = text(order, "resource_type").toLowerCase(Locale.ROOT);
|
||
if (number(snapshot, prefix + "_delegatable_sun")
|
||
- number(wallet, prefix + "_retain_sun")
|
||
- number(wallet, prefix + "_reserved_sun")
|
||
< number(source, "amount_sun")) {
|
||
return;
|
||
}
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> current = store.get("order", orderId, true);
|
||
Map<String, Object> latest = store.get("wallet", number(wallet, "id"), true);
|
||
if (!"RECOVERING".equals(text(current, "reclaim_status"))) {
|
||
return null;
|
||
}
|
||
require(
|
||
number(latest, "version") == number(wallet, "version")
|
||
&& number(snapshot, "snapshot_block_height")
|
||
>= number(latest, "snapshot_min_block_height"),
|
||
"资源恢复快照已过时");
|
||
store.update("wallet", number(wallet, "id"), snapshot);
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map(
|
||
"reclaim_status",
|
||
"DONE",
|
||
"relation_slot",
|
||
null,
|
||
"next_reclaim_at",
|
||
null));
|
||
orders.webhook(current, "RECLAIMED", "ORDER:" + orderId + ":RECLAIMED");
|
||
store.event("ORDER", orderId, "RECLAIMED", 0, "原本金已撤销且可委托资源恢复");
|
||
return null;
|
||
});
|
||
}
|
||
|
||
/** 无txId的未知任务只能补充独立核实的原交易,不能直接标失败或重新派单。 */
|
||
public void attach(long taskId, String txId, long actor, String reason) {
|
||
Map<String, Object> task = store.get("task", taskId, false);
|
||
require(
|
||
task.get("active_slot") != null
|
||
&& !Arrays.asList("REJECTED", "FAILED").contains(text(task, "status")),
|
||
"只能补充原在途任务的交易证据");
|
||
Map<String, Object> wallet = store.get("wallet", number(task, "wallet_id"), false);
|
||
Map<String, Object> order = store.get("order", number(task, "order_id"), false);
|
||
chain.verify(task, txId, text(wallet, "address"), text(order, "receiver_address"));
|
||
report(
|
||
number(task, "node_id"),
|
||
map(
|
||
"task_no",
|
||
text(task, "task_no"),
|
||
"event_id",
|
||
RentalValues.id("ADMIN"),
|
||
"state",
|
||
"BUILT",
|
||
"tx_id",
|
||
txId));
|
||
tx(
|
||
() -> {
|
||
store.event("TASK", taskId, "ATTACH_ORIGINAL_TX", actor, reason);
|
||
return null;
|
||
});
|
||
verify(taskId);
|
||
}
|
||
|
||
/** 异常委托完成原本金回收后,人工可终结未确认收入的HELD订单,不能释放未知在途。 */
|
||
public void resolveRecovered(long orderId, long actor, String reason) {
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> order = store.get("order", orderId, true);
|
||
require(
|
||
"MANUAL_REVIEW".equals(text(order, "status"))
|
||
&& "DONE".equals(text(order, "reclaim_status"))
|
||
&& "HELD".equals(text(order, "fund_status")),
|
||
"仅本金及资源已确认回收的人工核对冻结单可解冻");
|
||
funds.release(order);
|
||
store.update("order", orderId, map("status", "FAILED", "remark", reason));
|
||
orders.webhook(order, "FAILED", "ORDER:" + orderId + ":FAILED");
|
||
store.event("ORDER", orderId, "RESOLVE_AFTER_RECLAIM", actor, reason);
|
||
return null;
|
||
});
|
||
}
|
||
|
||
/** 在租期间监测外部提前撤销/追加。发现差异只隔离,不擅自撤销他人本金或自动退款。 */
|
||
public void monitor(long orderId) {
|
||
Map<String, Object> order = store.get("order", orderId, false);
|
||
if (!"SUCCESS".equals(text(order, "status"))
|
||
|| !"WAITING".equals(text(order, "reclaim_status"))) {
|
||
return;
|
||
}
|
||
Map<String, Object> wallet = store.get("wallet", number(order, "wallet_id"), false);
|
||
Map<String, Object> source =
|
||
store.one(
|
||
"SELECT x.* FROM rent_transaction x JOIN rent_task t ON t.id=x.task_id"
|
||
+ " WHERE t.order_id=? AND t.task_type='DELEGATE' AND"
|
||
+ " x.status='CONFIRMED'",
|
||
orderId);
|
||
require(source != null, "缺少原始委托证据");
|
||
long current =
|
||
chain.relation(
|
||
text(order, "network"),
|
||
text(wallet, "address"),
|
||
text(order, "receiver_address"),
|
||
text(order, "resource_type"));
|
||
if (current != number(source, "amount_sun")) {
|
||
tx(
|
||
() -> {
|
||
Map<String, Object> latest = store.get("order", orderId, true);
|
||
if ("SUCCESS".equals(text(latest, "status"))
|
||
&& "WAITING".equals(text(latest, "reclaim_status"))) {
|
||
store.update(
|
||
"order",
|
||
orderId,
|
||
map(
|
||
"status",
|
||
"MANUAL_REVIEW",
|
||
"reclaim_status",
|
||
"MANUAL_REVIEW",
|
||
"error_code",
|
||
"DELEGATION_CHANGED",
|
||
"next_reclaim_at",
|
||
after(60)));
|
||
store.event(
|
||
"ORDER",
|
||
orderId,
|
||
"DELEGATION_CHANGED",
|
||
0,
|
||
"原地址对委托关系已发生外部变化,隔离并等待人工处理");
|
||
}
|
||
return null;
|
||
});
|
||
}
|
||
}
|
||
}
|