代理租赁实现

This commit is contained in:
lu7213 committed 2026-10-22 19:58:57 -04:00
1 parent 1c0544afe0
commit 2a9f1c4c7c
38 files changed
+5824 -6

No files matched your search

@@ -0,0 +1,862 @@
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
public class RentalTasks {
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");
}
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 (chain.relation(
text(initial, "network"),
owner,
text(initial, "receiver_address"),
type)
!= 0) {
continue;
}
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)) {
return;
}
}
}
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 =
"DELEGATE".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",
"DELEGATE".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",
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);
}
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",
"DELEGATE".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 ("DELEGATE".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",
"已认证节点事件,成功仍须独立链上核验"));
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.put("evidence", orders.encode(proof));
fields.put("confirmed_at", now());
store.update("transaction", number(record, "id"), fields);
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"));
boolean delivered =
Boolean.TRUE.equals(proof.get("delivery_proven"))
&& number(proof, "verified_resource_quantity")
>= number(order, "target_resource_quantity")
&& expires.isAfter(Instant.now());
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.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) {
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, "明确拒绝未构建或链上确认失败;未知不走本分支");
}
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;
});
}
}
}