Files
usdt/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalTasks.java
T

959 lines
51 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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;
});
}
}
}