建议统一成“收益结算 + 提现付款” 按建议的逻辑帮我实现。

This commit is contained in:
lu7213 committed 2026-11-03 02:48:03 -05:00
1 parent 1151dc2535
commit be6ac23844
18 files changed
+352 -16

No files matched your search

+4
View File
@@ -2,6 +2,10 @@
## 业务与费用 ## 业务与费用
同一网络、同一接收地址只能存在一笔待处理的地址上链订单,限制跨应用、跨用户生效。WAITING、EXECUTING、VERIFYING、MANUAL_REVIEW 均占用名额;只有 SUCCESS、FAILED、CANCELLED 释放。相同商户订单号及参数重试仍返回原单,不重复冻结。失败或取消后可重试,但仍须通过链上未激活校验。数据库唯一索引防止并发绕过检查。
已有数据库需先执行 `sql/rent_onchain_pending_migration.sql`;若有历史重复待处理订单,脚本拒绝升级,需人工核实交易和资金状态后处理,禁止直接删除或批量取消。
用户在“我的套餐”或“我的订单”中的“地址上链”卡片输入网络、接收地址及应用凭证,获取报价后确认。即使没有资源套餐,也能创建地址上链订单。供应商通过原有 rent_node 及已证明所有权的 rent_wallet 执行,不需要供应商创建 rent_app。 用户在“我的套餐”或“我的订单”中的“地址上链”卡片输入网络、接收地址及应用凭证,获取报价后确认。即使没有资源套餐,也能创建地址上链订单。供应商通过原有 rent_node 及已证明所有权的 rent_wallet 执行,不需要供应商创建 rent_app。
地址上链使用独立路径 `/api/rental/v1/address-onchain/quote`、`/create`、`/query`,订单类型由路径固定为 `ADDRESS_ONCHAIN`,请求可省略order_type;若提交只能为ADDRESS_ONCHAIN。原 `/api/rental/v1/quote`、`/create`、`/query` 仅处理 `RESOURCE_RENTAL`,拒绝混用订单类型。两者复用签名、应用归属、商户单号幂等、账务及回调机制。原地址上链接入方需同时更新请求URL和HMAC签名中的完整路径,不能用旧路径签名请求新接口;已有订单可通过新的query路径按原商户单号查询。 地址上链使用独立路径 `/api/rental/v1/address-onchain/quote`、`/create`、`/query`,订单类型由路径固定为 `ADDRESS_ONCHAIN`,请求可省略order_type;若提交只能为ADDRESS_ONCHAIN。原 `/api/rental/v1/quote`、`/create`、`/query` 仅处理 `RESOURCE_RENTAL`,拒绝混用订单类型。两者复用签名、应用归属、商户单号幂等、账务及回调机制。原地址上链接入方需同时更新请求URL和HMAC签名中的完整路径,不能用旧路径签名请求新接口;已有订单可通过新的query路径按原商户单号查询。
+28
View File
@@ -0,0 +1,28 @@
# 供应商收益结算与提现付款
## 资金流程
履约成功且收入已确认 → 管理员创建收益结算单 → 另一管理员审核 → 待结算收益转入可用余额 → 供应商申请提现 → 冻结金额 → 管理员或Telegram审核 → 执行付款 → 人工登记并核验或自动扫描匹配 → 扣除冻结金额。
结算仅做内部划转,提现才对应链上出款。沿用现有提现配置、权限和到账机制,供应商需具备 `rent:withdraw:create` 权限。
## 表与接口
- `rent_settlement.settlement_mode`:新单固定 `INTERNAL_TRANSFER`,历史单为 `LEGACY_PAYOUT`,不接受前端指定模式。
- `rent_settlement_item`:同一供应商账户、同网络订单净收益快照;每单只允许一次有效结算,拒绝后释放来源。
- `POST /rental/settlement`:提交1至100个不重复的 `order_ids`,均须 `SUCCESS` 且 `CHARGED`。
- `POST /rental/settlement/{id}/approve`:提交 `reason`,审批者不能是创建者;同事务验证明细和账户ACTIVE状态,以唯一流水 `INCOME_SETTLE:{id}` 增加可用、等额减少待结算。结果为 `SETTLED` 并记录 `settled_at`。重复审批不重复划转。
- `POST /rental/settlement/{id}/reject`:其他管理员拒绝待审单,不修改资金,释放明细占位。
- 新单禁止 `pay/unknown/confirm`,完成结算后不允许拒绝撤销。提现使用原 `/rental/withdraw/create` 等接口。
SETTLED后仍保留来源占位。沿用退款保护:被结算占用的来源不得直接冲正供应商收入或向其返还手续费;待审单可先拒绝后处理退款。已结算收益的后续冲正需独立资金追偿业务,不能从其他订单待结算收益中冒扣,此版本不开放该操作。
## 升级与旧单
停服备份后执行 `sql/rent_income_settlement_migration.sql`,再部署新后端和前端。脚本可重复执行,仅增加模式与入账时间字段,不更改余额和历史状态。不要在旧、新版本混跑时创建结算单。
所有历史单保持 `LEGACY_PAYOUT`,继续原审批、付款授权和交易核验,完成只扣待结算,不增加可用,防止重复提现。历史PENDING/APPROVED且明确未付款的单可先按原规则拒绝,再创建新收益结算单;PAYING/UNKNOWN不能自动拒绝或转换。不得直接改模式或删除明细绕过来源占位。
## 排查
按 `settlementId` 查创建、审批幂等、入账或拒绝日志。核对明细合计、来源订单净应收、账户状态及 `rent_ledger` 的 `INCOME_SETTLE` 记录。划转前后可用与待结算之和不变,冻结与平台手续费不变;提现另外记账。
+1 -1
View File
@@ -106,7 +106,7 @@ node --env-file=.env src/index.js
每天UTC02:00自动进行账账核对,发现差异只告警,不直接修复余额或释放未知本金。运营可在资金账户/流水页主动执行完整分页核对。 每天UTC02:00自动进行账账核对,发现差异只告警,不直接修复余额或释放未知本金。运营可在资金账户/流水页主动执行完整分页核对。
结算 `pay` 先持久化唯一 `payout_no` 及本次收款地址,再由人工付款;重试返回原授权,不产生新的付款。`confirm` 根据原授权收款地址、账户网络及精确USDT金额核对原交易日志。后端不自动对外出金。 新结算单使用 `INTERNAL_TRANSFER` 模式,其他管理员 `approve` 后将供应商净收益从待结算转入可用余额,状态为 `SETTLED`,不执行链上付款。对外付款统一通过提现处理。`LEGACY_PAYOUT` 仅兼容升级前付款单,保留原授权和交易核验,不转入内部余额。见 `../rental-income-settlement.md`。
## 6. 外部商户签名接口 ## 6. 外部商户签名接口
@@ -25,6 +25,18 @@ public class RentSettlement extends BaseEntity
@Excel(name = "结算单号") @Excel(name = "结算单号")
private String settlementNo; private String settlementNo;
/** INTERNAL_TRANSFER为收益入账;LEGACY_PAYOUT仅处理升级前付款单。 */
@Excel(name = "结算模式")
private String settlementMode;
/** 内部结算完成时间,与历史链上付款时间分开记录。 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date settledAt;
public String getSettlementMode() { return settlementMode; }
public void setSettlementMode(String settlementMode) { this.settlementMode = settlementMode; }
public Date getSettledAt() { return settledAt; }
public void setSettledAt(Date settledAt) { this.settledAt = settledAt; }
/** 供应商rent_account.id */ /** 供应商rent_account.id */
@Excel(name = "供应商rent_account.id") @Excel(name = "供应商rent_account.id")
private Long accountId; private Long accountId;
@@ -26,6 +26,18 @@ public class RentSettlementPlus implements Serializable
/** 结算单号 */ /** 结算单号 */
@Excel(name = "结算单号") @Excel(name = "结算单号")
private String settlementNo; private String settlementNo;
/** INTERNAL_TRANSFER为收益入账;LEGACY_PAYOUT仅处理升级前付款单。 */
@Excel(name = "结算模式")
private String settlementMode;
/** 内部结算完成时间,与历史链上付款时间分开记录。 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date settledAt;
public String getSettlementMode() { return settlementMode; }
public void setSettlementMode(String settlementMode) { this.settlementMode = settlementMode; }
public Date getSettledAt() { return settledAt; }
public void setSettledAt(Date settledAt) { this.settledAt = settledAt; }
/** 供应商rent_account.id */ /** 供应商rent_account.id */
@Excel(name = "供应商rent_account.id") @Excel(name = "供应商rent_account.id")
private Long accountId; private Long accountId;
@@ -362,6 +362,8 @@ public class RentalController {
Map<String, Object> row = store.get("settlement", id, false), Map<String, Object> row = store.get("settlement", id, false),
account = store.get("account", number(row, "account_id"), false); account = store.get("account", number(row, "account_id"), false);
Map<String, Object> authorization; Map<String, Object> authorization;
require("LEGACY_PAYOUT".equals(text(row, "settlement_mode")),
"收益结算不接受链上付款登记,请使用提现功能");
try { try {
authorization = authorization =
new com.fasterxml.jackson.databind.ObjectMapper() new com.fasterxml.jackson.databind.ObjectMapper()
@@ -209,6 +209,15 @@ public class RentalOrders {
log.info("地址上链幂等命中 orderId={} network={}", existing.get("id"), network); log.info("地址上链幂等命中 orderId={} network={}", existing.get("id"), network);
return existing; return existing;
} }
// 跨应用、跨用户检查;人工核对仍可能已广播,不能视为可重新下单。
Map<String, Object> pending = store.one("SELECT id FROM rent_order WHERE network=?"
+ " AND receiver_address=? AND order_type='ADDRESS_ONCHAIN'"
+ " AND status NOT IN ('SUCCESS','FAILED','CANCELLED') LIMIT 1", network, receiver);
if (pending != null) {
log.warn("地址上链重复下单已拒绝 network={} receiver={} pendingOrderId={} userId={}",
network, receiver, pending.get("id"), user);
throw new IllegalArgumentException("该地址在当前网络已有待处理的上链订单,请等待原订单完成");
}
Map<String, Object> price = onchain.quote(request); Map<String, Object> price = onchain.quote(request);
// 在任何账户创建、订单写入和资金冻结前查询最新链上状态;RPC未知时直接中止。 // 在任何账户创建、订单写入和资金冻结前查询最新链上状态;RPC未知时直接中止。
// 必须位于原单幂等返回之后,已成功激活的原订单仍可安全重试和查询。 // 必须位于原单幂等返回之后,已成功激活的原订单仍可安全重试和查询。
@@ -234,7 +243,19 @@ public class RentalOrders {
"status", "WAITING", "payer_account_id", account.get("id"), "fund_status", "HELD", "status", "WAITING", "payer_account_id", account.get("id"), "fund_status", "HELD",
"dispatch_deadline", after(300), "reclaim_status", "NOT_REQUIRED", "dispatch_deadline", after(300), "reclaim_status", "NOT_REQUIRED",
"notify_url", notify.isEmpty() ? null : notify); "notify_url", notify.isEmpty() ? null : notify);
long orderId = store.insert("order", order); long orderId;
try {
// 数据库唯一索引兜底,防止不同应用或服务实例同时通过上面的预检查。
orderId = store.insert("order", order);
} catch (org.springframework.dao.DuplicateKeyException exception) {
if (exception.getMostSpecificCause().getMessage() != null
&& exception.getMostSpecificCause().getMessage().toLowerCase(java.util.Locale.ROOT)
.contains("uk_order_onchain_pending")) {
log.warn("地址上链并发重复下单已拒绝 network={} receiver={} userId={}", network, receiver, user);
throw new IllegalArgumentException("该地址在当前网络已有待处理的上链订单,请等待原订单完成");
}
throw exception;
}
order.put("id", orderId); order.put("id", orderId);
funds.hold(order); funds.hold(order);
log.info("地址上链分账已锁定 orderId={} platformPercent={} platformFeeUsdt={} supplierNetUsdt={}", log.info("地址上链分账已锁定 orderId={} platformPercent={} platformFeeUsdt={} supplierNetUsdt={}",
@@ -10,7 +10,10 @@ import java.util.*;
/** 人工退款及结算审批;审批者与发起者分离,付款未知绝不释放来源。 */ /** 人工退款及结算审批;审批者与发起者分离,付款未知绝不释放来源。 */
@Service @Service
@lombok.extern.slf4j.Slf4j
public class RentalReviews { public class RentalReviews {
/** 新单仅内部划转;历史单继续按原付款授权处理,禁止混用两种记账方式。 */
private static final String INTERNAL_TRANSFER = "INTERNAL_TRANSFER";
private final RentalStore store; private final RentalStore store;
private final RentalFunds funds; private final RentalFunds funds;
private final RentalOrders orders; private final RentalOrders orders;
@@ -202,6 +205,9 @@ public class RentalReviews {
for (long orderId : sorted) { for (long orderId : sorted) {
Map<String, Object> order = store.get("order", orderId, true); Map<String, Object> order = store.get("order", orderId, true);
require("CHARGED".equals(text(order, "fund_status")), "来源订单尚未确认收入"); require("CHARGED".equals(text(order, "fund_status")), "来源订单尚未确认收入");
require("SUCCESS".equals(text(order, "status")), "仅履约成功订单允许收益结算");
require(store.one("SELECT id FROM rent_settlement_item WHERE order_id=? AND active_slot=1", orderId)
== null, "来源订单已被结算占用或已结算");
long current = number(order, "supplier_account_id"); long current = number(order, "supplier_account_id");
require(account == null || account == current, "只允许同一供应商同网络的来源"); require(account == null || account == current, "只允许同一供应商同网络的来源");
account = current; account = current;
@@ -225,6 +231,8 @@ public class RentalReviews {
total, total,
"status", "status",
"PENDING", "PENDING",
"settlement_mode",
INTERNAL_TRANSFER,
"created_by", "created_by",
actor)); actor));
for (Map<String, Object> source : sources) { for (Map<String, Object> source : sources) {
@@ -233,6 +241,8 @@ public class RentalReviews {
store.insert("settlement_item", source); store.insert("settlement_item", source);
} }
store.event("SETTLEMENT", id, "CREATE", actor, "占用订单净应收来源"); store.event("SETTLEMENT", id, "CREATE", actor, "占用订单净应收来源");
log.info("收益结算单创建 settlementId={} accountId={} amountUsdt={} sourceCount={} actorId={} mode={}",
id, account, total, sorted.size(), actor, INTERNAL_TRANSFER);
return id; return id;
} }
@@ -240,6 +250,12 @@ public class RentalReviews {
public Map<String, Object> transition(long id, String action, long actor, String reason) { public Map<String, Object> transition(long id, String action, long actor, String reason) {
Map<String, Object> row = store.get("settlement", id, true); Map<String, Object> row = store.get("settlement", id, true);
String state = text(row, "status"); String state = text(row, "status");
log.info("结算操作检查 settlementId={} mode={} state={} action={} actorId={}",
id, text(row, "settlement_mode"), state, action, actor);
if (INTERNAL_TRANSFER.equals(text(row, "settlement_mode"))) {
return internalSettlement(row, action, actor, reason);
}
require("LEGACY_PAYOUT".equals(text(row, "settlement_mode")), "结算模式无效,请检查数据库升级");
if ("approve".equals(action)) { if ("approve".equals(action)) {
require("PENDING".equals(state) && number(row, "created_by") != actor, "审批须职责分离"); require("PENDING".equals(state) && number(row, "created_by") != actor, "审批须职责分离");
store.update( store.update(
@@ -279,10 +295,67 @@ public class RentalReviews {
return store.get("settlement", id, false); return store.get("settlement", id, false);
} }
/**
* 调用方已锁结算单。审批、来源核对、余额划转及审计在同一事务提交。
* SETTLED不代表对外付款;来源占位永久保留,之后仅可从可用余额申请提现。
*/
private Map<String, Object> internalSettlement(Map<String, Object> row, String action, long actor, String reason) {
long id = number(row, "id");
String state = text(row, "status");
if ("approve".equals(action)) {
if ("SETTLED".equals(state)) {
log.info("收益结算审批幂等返回 settlementId={} actorId={}", id, actor);
return row;
}
require("PENDING".equals(state) && number(row, "created_by") != actor, "审批须职责分离且结算单待审核");
List<Map<String, Object>> items = store.rows(
"SELECT * FROM rent_settlement_item WHERE settlement_id=? ORDER BY order_id", id);
require(!items.isEmpty(), "结算来源不能为空");
BigDecimal total = ZERO;
for (Map<String, Object> item : items) {
Map<String, Object> order = store.get("order", number(item, "order_id"), true);
BigDecimal net = amount(order, "supplier_net_amount")
.subtract(amount(order, "supplier_reversed_amount"))
.add(amount(order, "supplier_fee_returned_amount"));
require(number(item, "active_slot") == 1 && "CHARGED".equals(text(order, "fund_status"))
&& "SUCCESS".equals(text(order, "status"))
&& number(order, "supplier_account_id") == number(row, "account_id")
&& net.signum() > 0 && net.compareTo(amount(item, "amount")) == 0,
"来源订单状态或净应收已变更,请拒绝后重新创建结算单");
total = total.add(net);
}
require(total.compareTo(amount(row, "amount")) == 0, "结算明细金额不一致");
Map<String, Object> account = store.get("account", number(row, "account_id"), true);
require("ACTIVE".equals(text(account, "status")), "供应商账户已冻结,暂不能结算");
funds.post(number(row, "account_id"), "INCOME_SETTLE:" + id, "INCOME_SETTLE",
total, ZERO, total.negate(), ZERO, null, id, null, actor, null,
"收益结算转入可用余额:" + reason);
store.update("settlement", id, map("status", "SETTLED", "approved_by", actor,
"settled_at", now(), "remark", reason));
store.event("SETTLEMENT", id, "INCOME_SETTLE", actor, reason);
log.info("收益结算完成 settlementId={} accountId={} amountUsdt={} actorId={} sourceCount={}",
id, row.get("account_id"), total, actor, items.size());
} else if ("reject".equals(action)) {
if ("REJECTED".equals(state)) {
return row;
}
require("PENDING".equals(state) && number(row, "created_by") != actor, "只能由其他审批人拒绝待审收益结算单");
store.update("settlement", id, map("status", "REJECTED", "approved_by", actor, "remark", reason));
store.execute("UPDATE rent_settlement_item SET active_slot=NULL,version=version+1,updated_at=? WHERE settlement_id=?", now(), id);
store.event("SETTLEMENT", id, "REJECT", actor, reason);
log.info("收益结算拒绝并释放来源 settlementId={} actorId={}", id, actor);
} else {
log.warn("收益结算拒绝旧付款操作 settlementId={} action={} actorId={}", id, action, actor);
throw new IllegalArgumentException("收益结算只支持审核入账或拒绝;对外付款请使用提现功能");
}
return store.get("settlement", id, false);
}
/** 由链上只读服务独立核对付款后调用;不接受前端的verified=true作为依据。 */ /** 由链上只读服务独立核对付款后调用;不接受前端的verified=true作为依据。 */
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public void paid(long id, String reference, String evidence, long actor) { public void paid(long id, String reference, String evidence, long actor) {
Map<String, Object> row = store.get("settlement", id, true); Map<String, Object> row = store.get("settlement", id, true);
require("LEGACY_PAYOUT".equals(text(row, "settlement_mode")), "收益结算不能登记链上付款,请通过提现付款");
if ("PAID".equals(text(row, "status"))) { if ("PAID".equals(text(row, "status"))) {
require(reference.equals(text(row, "payment_reference")), "付款凭据冲突"); require(reference.equals(text(row, "payment_reference")), "付款凭据冲突");
return; return;
@@ -7,7 +7,6 @@ import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.Statement;
import java.util.*; import java.util.*;
/** 租赁事务仓储。动态标识符只接受内部白名单,业务值全部使用占位符。 行锁由调用方事务持有;RPC必须在事务外执行,避免占用数据库连接等待链上响应。 */ /** 租赁事务仓储。动态标识符只接受内部白名单,业务值全部使用占位符。 行锁由调用方事务持有;RPC必须在事务外执行,避免占用数据库连接等待链上响应。 */
@@ -93,7 +92,8 @@ public class RentalStore {
jdbc.update( jdbc.update(
connection -> { connection -> {
PreparedStatement ps = PreparedStatement ps =
connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS); // 只读取自增主键,避免生成列也被驱动返回为 generated keys。
connection.prepareStatement(sql, new String[] {"id"});
int index = 1; int index = 1;
for (Object value : values.values()) { for (Object value : values.values()) {
ps.setObject(index++, value); ps.setObject(index++, value);
@@ -7,6 +7,8 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<resultMap type="RentSettlement" id="RentSettlementResult"> <resultMap type="RentSettlement" id="RentSettlementResult">
<result property="id" column="id" /> <result property="id" column="id" />
<result property="settlementNo" column="settlement_no" /> <result property="settlementNo" column="settlement_no" />
<result property="settlementMode" column="settlement_mode" />
<result property="settledAt" column="settled_at" />
<result property="accountId" column="account_id" /> <result property="accountId" column="account_id" />
<result property="amount" column="amount" /> <result property="amount" column="amount" />
<result property="status" column="status" /> <result property="status" column="status" />
@@ -24,7 +26,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
</resultMap> </resultMap>
<sql id="selectRentSettlementVo"> <sql id="selectRentSettlementVo">
select id, settlement_no, account_id, amount, status, payout_no, payment_started_at, payment_evidence, payment_reference, created_by, approved_by, paid_at, remark, version, created_at, updated_at from rent_settlement select id, settlement_no, settlement_mode, settled_at, account_id, amount, status, payout_no, payment_started_at, payment_evidence, payment_reference, created_by, approved_by, paid_at, remark, version, created_at, updated_at from rent_settlement
</sql> </sql>
<select id="selectRentSettlementList" parameterType="RentSettlement" resultMap="RentSettlementResult"> <select id="selectRentSettlementList" parameterType="RentSettlement" resultMap="RentSettlementResult">
@@ -109,4 +111,4 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
#{id} #{id}
</foreach> </foreach>
</delete> </delete>
</mapper> </mapper>
@@ -492,6 +492,7 @@ public class RentalBusinessTest {
Files.readAllBytes(Paths.get("../sql/rent_init.sql")), Files.readAllBytes(Paths.get("../sql/rent_init.sql")),
StandardCharsets.UTF_8) StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "") .replaceAll("(?m)^--.*$", "")
.replace("GENERATED ALWAYS AS", "AS")
.replaceAll("CHARACTER SET ascii COLLATE ascii_bin", "") .replaceAll("CHARACTER SET ascii COLLATE ascii_bin", "")
.replaceAll("(?i)\\bJSON\\b", "LONGTEXT") .replaceAll("(?i)\\bJSON\\b", "LONGTEXT")
.replaceAll( .replaceAll(
@@ -915,6 +916,139 @@ public class RentalBusinessTest {
assertEquals(1, activationChecks); assertEquals(1, activationChecks);
} }
@Test
public void onchainPendingAddressBlocksNewOrderUntilCancelled() {
Map<String, Object> original = tx.execute(status -> orders.create(app, 10, onchainRequest("pending-first")));
BigDecimal frozen = amount(store.get("account", payer, false), "frozen_amount");
long otherApp = store.insert("app", map("user_id", 30, "name", "other-user", "status", "ACTIVE"));
expectFailure(() -> tx.execute(status -> orders.create(otherApp, 30, onchainRequest("other-user-order"))));
for (String state : new String[] {"WAITING", "EXECUTING", "VERIFYING", "MANUAL_REVIEW"}) {
store.update("order", number(original, "id"), map("status", state));
expectFailure(() -> tx.execute(status -> orders.create(app, 10, onchainRequest("pending-second"))));
assertEquals(frozen, amount(store.get("account", payer, false), "frozen_amount"));
}
store.update("order", number(original, "id"), map("status", "WAITING"));
tx.execute(status -> { orders.cancel(number(original, "id"), 10); return null; });
Map<String, Object> next = tx.execute(status -> orders.create(app, 10, onchainRequest("pending-second")));
assertNotEquals(number(original, "id"), number(next, "id"));
}
@Test
public void onchainPendingIndexRejectsDuplicateEvenWithoutBusinessCheck() {
Map<String, Object> original = tx.execute(status -> orders.create(app, 10, onchainRequest("index-first")));
Map<String, Object> duplicate = new java.util.HashMap<>(original);
duplicate.remove("id");
duplicate.remove("onchain_pending_slot");
duplicate.put("order_no", "duplicate-index-order");
duplicate.put("merchant_order_no", "duplicate-index-merchant");
try {
tx.execute(status -> store.insert("order", duplicate));
fail("数据库必须拒绝同地址的并发待处理订单");
} catch (org.springframework.dao.DuplicateKeyException expected) {
assertTrue(expected.getMostSpecificCause().getMessage().toLowerCase(java.util.Locale.ROOT)
.contains("uk_order_onchain_pending"));
}
}
private static void await(CountDownLatch latch) {
try {
if (!latch.await(10, TimeUnit.SECONDS)) {
throw new IllegalStateException("等待并发测试启动超时");
}
} catch (InterruptedException exception) {
Thread.currentThread().interrupt();
throw new IllegalStateException(exception);
}
}
/** 真实冻结与确认记账,链上证明由其他用例覆盖;这里隔离收益结算资金流。 */
private long incomeOrder() {
return tx.execute(status -> {
Map<String, Object> order = orders.create(app, 10, onchainRequest("income-source"));
long id = number(order, "id");
store.update("order", id, map("status", "SUCCESS", "supplier_account_id", supplier,
"supplier_user_id", 20));
funds.charge(store.get("order", id, true));
return id;
});
}
@Test
public void incomeApprovalMovesBalanceExactlyOnceAndCannotPayOrResettle() throws Exception {
long order = incomeOrder();
long settlement = tx.execute(status -> reviews.settlement(Collections.singletonList(order), 90));
expectFailure(() -> tx.execute(status -> reviews.transition(settlement, "approve", 90, "self")));
expectFailure(() -> tx.execute(status -> reviews.transition(settlement, "pay", 91, "wrong-mode")));
ExecutorService executor = Executors.newFixedThreadPool(2);
CountDownLatch start = new CountDownLatch(1);
try {
Future<?> first = executor.submit(() -> { await(start); tx.execute(status -> reviews.transition(settlement, "approve", 91, "审核")); });
Future<?> second = executor.submit(() -> { await(start); tx.execute(status -> reviews.transition(settlement, "approve", 92, "重试")); });
start.countDown();
first.get(15, TimeUnit.SECONDS);
second.get(15, TimeUnit.SECONDS);
} finally { executor.shutdownNow(); }
assertEquals("SETTLED", text(store.get("settlement", settlement, false), "status"));
assertNotNull(store.get("settlement", settlement, false).get("settled_at"));
assertNull(store.get("settlement", settlement, false).get("paid_at"));
assertEquals(money("0.163457"), amount(store.get("account", supplier, false), "available_amount"));
assertEquals(ZERO, amount(store.get("account", supplier, false), "supplier_pending_amount"));
assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE business_key=?", "INCOME_SETTLE:" + settlement).size());
expectFailure(() -> tx.execute(status -> reviews.settlement(Collections.singletonList(order), 90)));
expectFailure(() -> tx.execute(status -> reviews.transition(settlement, "reject", 91, "too-late")));
expectFailure(() -> tx.execute(status -> { reviews.paid(settlement, "fake", "{}", 91); return null; }));
// 结算收入进入现有提现入口,不需要供应商专用付款或重复的结算付款逻辑。
org.springframework.core.env.StandardEnvironment env = new org.springframework.core.env.StandardEnvironment();
env.getPropertySources().addFirst(new org.springframework.core.env.MapPropertySource("withdraw-income", map(
"rental.enabled", true, "rental.withdraw.enabled", true, "rental.withdraw.min-amount-usdt", "0.01",
"rental.withdraw.nile.payout-addresses", "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb")));
RentalWithdrawals withdraw = new RentalWithdrawals(store, funds, null, env,
new ObjectMapper(), null, tx.getTransactionManager());
Map<String, Object> request = map("network", "NILE", "receiver_address", ADDRESS,
"client_request_no", "income-withdraw", "amount", "0.1");
withdraw.create(20, request);
withdraw.create(20, request);
assertEquals(money("0.063457"), amount(store.get("account", supplier, false), "available_amount"));
assertEquals(money("0.100000"), amount(store.get("account", supplier, false), "frozen_amount"));
assertEquals(ZERO, amount(store.get("account", supplier, false), "supplier_pending_amount"));
}
@Test
public void incomeRejectReleasesSourcesAndFailedApprovalRollsBack() {
long order = incomeOrder();
long first = tx.execute(status -> reviews.settlement(Collections.singletonList(order), 90));
store.update("account", supplier, map("status", "DISABLED"));
expectFailure(() -> tx.execute(status -> reviews.transition(first, "approve", 91, "blocked")));
assertEquals("PENDING", text(store.get("settlement", first, false), "status"));
assertEquals(ZERO, amount(store.get("account", supplier, false), "available_amount"));
assertEquals(money("0.163457"), amount(store.get("account", supplier, false), "supplier_pending_amount"));
tx.execute(status -> reviews.transition(first, "reject", 91, "重新核对"));
store.update("account", supplier, map("status", "ACTIVE"));
long next = tx.execute(status -> reviews.settlement(Collections.singletonList(order), 90));
tx.execute(status -> reviews.transition(next, "approve", 91, "重新结算"));
assertEquals(money("0.163457"), amount(store.get("account", supplier, false), "available_amount"));
}
@Test
public void legacyPaidDoesNotCreditWithdrawableBalance() {
long order = incomeOrder();
long id = tx.execute(status -> reviews.settlement(Collections.singletonList(order), 90));
// 模拟升级前已存在的结算单;迁移脚本默认所有历史行均为LEGACY_PAYOUT。
store.update("settlement", id, map("settlement_mode", "LEGACY_PAYOUT"));
tx.execute(status -> {
reviews.transition(id, "approve", 91, "legacy");
reviews.transition(id, "pay", 91, "legacy");
reviews.paid(id, "NILE:legacy:0", "{}", 91);
reviews.paid(id, "NILE:legacy:0", "{}", 91);
return null;
});
assertEquals("PAID", text(store.get("settlement", id, false), "status"));
assertEquals(ZERO, amount(store.get("account", supplier, false), "available_amount"));
assertEquals(ZERO, amount(store.get("account", supplier, false), "supplier_pending_amount"));
expectFailure(() -> tx.execute(status -> reviews.settlement(Collections.singletonList(order), 90)));
}
private Map<String, Object> onchainRequest(String merchant) { private Map<String, Object> onchainRequest(String merchant) {
return map("order_type", "ADDRESS_ONCHAIN", "network", "NILE", "merchant_order_no", merchant, return map("order_type", "ADDRESS_ONCHAIN", "network", "NILE", "merchant_order_no", merchant,
"receiver_address", ADDRESS, "expected_amount", "0.173457"); "receiver_address", ADDRESS, "expected_amount", "0.173457");
@@ -1305,7 +1439,7 @@ public class RentalBusinessTest {
@Test @Test
public void historyCleanupReadsRealBusinessSchemaAndKeepsFunds() throws Exception { public void historyCleanupReadsRealBusinessSchemaAndKeepsFunds() throws Exception {
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8) String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "") .replaceAll("(?m)^--.*$", "").replace("GENERATED ALWAYS AS", "AS")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String statement : ddl.split(";")) { for (String statement : ddl.split(";")) {
if (!statement.trim().isEmpty()) { store.execute(statement); } if (!statement.trim().isEmpty()) { store.execute(statement); }
@@ -2225,6 +2359,8 @@ public class RentalBusinessTest {
tx.execute(status -> reviews.settlement(Collections.singletonList(id), 90)); tx.execute(status -> reviews.settlement(Collections.singletonList(id), 90));
tx.execute( tx.execute(
status -> { status -> {
// 仅历史模式仍允许领取付款授权,验证旧单UNKNOWN/PAYING占用保护。
store.update("settlement", settlement, map("settlement_mode", "LEGACY_PAYOUT"));
reviews.transition(settlement, "approve", 91, "test"); reviews.transition(settlement, "approve", 91, "test");
reviews.transition(settlement, "pay", 91, "test"); reviews.transition(settlement, "pay", 91, "test");
return null; return null;
@@ -43,7 +43,7 @@ public class RentalHistoryCleanupTest {
store = new RentalStore(jdbc); store = new RentalStore(jdbc);
manager = new DataSourceTransactionManager(source); manager = new DataSourceTransactionManager(source);
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8) String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "") .replaceAll("(?m)^--.*$", "").replace("GENERATED ALWAYS AS", "AS")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String statement : ddl.split(";")) { for (String statement : ddl.split(";")) {
if (!statement.trim().isEmpty()) { jdbc.execute(statement); } if (!statement.trim().isEmpty()) { jdbc.execute(statement); }
@@ -51,7 +51,7 @@ public class RentalHistoryTest {
jdbc.execute("CREATE ALIAS UTC_TIMESTAMP FOR \"com.ruoyi.system.rental.RentalHistoryTest.utcTimestamp\""); jdbc.execute("CREATE ALIAS UTC_TIMESTAMP FOR \"com.ruoyi.system.rental.RentalHistoryTest.utcTimestamp\"");
store = new RentalStore(jdbc); store = new RentalStore(jdbc);
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")),
StandardCharsets.UTF_8).replaceAll("(?m)^--.*$", "") StandardCharsets.UTF_8).replaceAll("(?m)^--.*$", "").replace("GENERATED ALWAYS AS", "AS")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String statement : ddl.split(";")) { for (String statement : ddl.split(";")) {
if (!statement.trim().isEmpty()) { if (!statement.trim().isEmpty()) {
@@ -64,7 +64,7 @@ public class RentalTopupTest {
store = new RentalStore(jdbc); store = new RentalStore(jdbc);
for (String file : Arrays.asList("rent_init.sql", "rent_topup_init.sql")) { for (String file : Arrays.asList("rent_init.sql", "rent_topup_init.sql")) {
String ddl = new String(Files.readAllBytes(Paths.get("../sql/" + file)), StandardCharsets.UTF_8) String ddl = new String(Files.readAllBytes(Paths.get("../sql/" + file)), StandardCharsets.UTF_8)
.replaceAll("(?m)^--.*$", "").replace("CHARACTER SET ascii COLLATE ascii_bin", "") .replaceAll("(?m)^--.*$", "").replace("GENERATED ALWAYS AS", "AS").replace("CHARACTER SET ascii COLLATE ascii_bin", "")
.replaceAll("(?i)\\bJSON\\b", "LONGTEXT") .replaceAll("(?i)\\bJSON\\b", "LONGTEXT")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String sql : ddl.split(";")) if (!sql.trim().isEmpty()) jdbc.execute(sql); for (String sql : ddl.split(";")) if (!sql.trim().isEmpty()) jdbc.execute(sql);
@@ -54,7 +54,7 @@ public class RentalWithdrawTest {
JdbcTemplate jdbc = new JdbcTemplate(source); JdbcTemplate jdbc = new JdbcTemplate(source);
store = new RentalStore(jdbc); store = new RentalStore(jdbc);
String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_init.sql")), StandardCharsets.UTF_8) 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("(?m)^--.*$", "").replace("GENERATED ALWAYS AS", "AS").replace("CHARACTER SET ascii COLLATE ascii_bin", "")
.replaceAll("(?i)\\bJSON\\b", "LONGTEXT") .replaceAll("(?i)\\bJSON\\b", "LONGTEXT")
.replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", "");
for (String sql : ddl.split(";")) { if (!sql.trim().isEmpty()) { jdbc.execute(sql); } } for (String sql : ddl.split(";")) { if (!sql.trim().isEmpty()) { jdbc.execute(sql); } }
+18
View File
@@ -0,0 +1,18 @@
-- MySQL 5.7/8.0。停服后升级,再部署新服务。保留所有历史单状态和资金,不将旧单转为内部划转。
DELIMITER $$
DROP PROCEDURE IF EXISTS migrate_rent_income_settlement$$
CREATE PROCEDURE migrate_rent_income_settlement()
BEGIN
IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE()
AND table_name='rent_settlement' AND column_name='settlement_mode') THEN
ALTER TABLE rent_settlement ADD COLUMN settlement_mode VARCHAR(24) NOT NULL DEFAULT 'LEGACY_PAYOUT'
COMMENT 'INTERNAL_TRANSFER收益划转;LEGACY_PAYOUT历史付款';
END IF;
IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE()
AND table_name='rent_settlement' AND column_name='settled_at') THEN
ALTER TABLE rent_settlement ADD COLUMN settled_at DATETIME(3) NULL COMMENT '内部收益结算完成时间';
END IF;
END$$
CALL migrate_rent_income_settlement()$$
DROP PROCEDURE migrate_rent_income_settlement$$
DELIMITER ;
+9 -5
View File
@@ -256,6 +256,8 @@ CREATE TABLE IF NOT EXISTS `rent_order` (
`updated_at` DATETIME(3) NOT NULL COMMENT '更新服务器本地时间,追加记录与创建时间相同', `updated_at` DATETIME(3) NOT NULL COMMENT '更新服务器本地时间,追加记录与创建时间相同',
PRIMARY KEY (`id`), PRIMARY KEY (`id`),
UNIQUE KEY `uk_order_no` (`order_no`), UNIQUE KEY `uk_order_no` (`order_no`),
`onchain_pending_slot` TINYINT GENERATED ALWAYS AS (CASE WHEN `order_type`='ADDRESS_ONCHAIN' AND `status` NOT IN ('SUCCESS','FAILED','CANCELLED') THEN 1 ELSE NULL END),
UNIQUE KEY `uk_order_onchain_pending` (`network`,`receiver_address`,`onchain_pending_slot`),
UNIQUE KEY `uk_merchant_order` (`app_id`,`merchant_order_no`), UNIQUE KEY `uk_merchant_order` (`app_id`,`merchant_order_no`),
UNIQUE KEY `uk_order_relation` (`wallet_id`,`receiver_address`,`resource_type`,`relation_slot`), UNIQUE KEY `uk_order_relation` (`wallet_id`,`receiver_address`,`resource_type`,`relation_slot`),
KEY `idx_order_schedule` (`status`,`created_at`), KEY `idx_order_schedule` (`status`,`created_at`),
@@ -357,7 +359,7 @@ CREATE TABLE IF NOT EXISTS `rent_ledger` (
`id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '记录主键', `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '记录主键',
`account_id` BIGINT NOT NULL COMMENT 'rent_account.id', `account_id` BIGINT NOT NULL COMMENT 'rent_account.id',
`business_key` VARCHAR(160) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '全局唯一记账键;普通业务含事件及账户,TOPUP仅按网络及链上事件唯一标识构造,不含账户以防跨用户重复充值', `business_key` VARCHAR(160) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '全局唯一记账键;普通业务含事件及账户,TOPUP仅按网络及链上事件唯一标识构造,不含账户以防跨用户重复充值',
`event_type` VARCHAR(24) NOT NULL COMMENT 'TOPUP充值、HOLD冻结、CHARGE扣款、RELEASE解冻、SUPPLIER_EARN毛应收、SUPPLIER_FEE供应商手续费、SETTLE净额结算、REFUND退款、REVERSAL冲正', `event_type` VARCHAR(24) NOT NULL COMMENT 'TOPUP充值、HOLD冻结、CHARGE扣款、RELEASE解冻、SUPPLIER_EARN毛应收、SUPPLIER_FEE手续费、INCOME_SETTLE收益入账、SETTLE历史付款、REFUND退款、REVERSAL冲正',
`delta_available` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '可用余额变化,有正负', `delta_available` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '可用余额变化,有正负',
`delta_frozen` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '冻结余额变化,有正负', `delta_frozen` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '冻结余额变化,有正负',
`delta_supplier_pending` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '供应商待结算变化,有正负', `delta_supplier_pending` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '供应商待结算变化,有正负',
@@ -383,13 +385,15 @@ CREATE TABLE IF NOT EXISTS `rent_ledger` (
KEY `idx_ledger_order` (`order_id`,`id`) KEY `idx_ledger_order` (`order_id`,`id`)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='不可变租赁资金流水;余额与流水同事务,冲正追加不覆盖'; ) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='不可变租赁资金流水;余额与流水同事务,冲正追加不覆盖';
-- 供应商人工结算单;不自动链上出金 -- 供应商收益结算;新单内部划转,历史单保留原付款处理
CREATE TABLE IF NOT EXISTS `rent_settlement` ( CREATE TABLE IF NOT EXISTS `rent_settlement` (
`id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '记录主键', `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '记录主键',
`settlement_no` VARCHAR(40) NOT NULL COMMENT '结算单号', `settlement_no` VARCHAR(40) NOT NULL COMMENT '结算单号',
`settlement_mode` VARCHAR(24) NOT NULL DEFAULT 'LEGACY_PAYOUT' COMMENT 'INTERNAL_TRANSFER收益划转;LEGACY_PAYOUT历史对外付款,新业务显式写INTERNAL_TRANSFER',
`settled_at` DATETIME(3) NULL COMMENT '收益转入可用余额完成时间;不同于历史付款paid_at',
`account_id` BIGINT NOT NULL COMMENT '供应商rent_account.id', `account_id` BIGINT NOT NULL COMMENT '供应商rent_account.id',
`amount` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '本次人工结算USDT总额,必须大于零', `amount` DECIMAL(30,6) NOT NULL DEFAULT 0 COMMENT '本次净收益结算USDT总额,必须大于零',
`status` VARCHAR(32) NOT NULL DEFAULT 'PENDING' COMMENT 'PENDING待审、APPROVED待付款、PAYING已占用付款授权、PAID付款核验完成、REJECTED明确未付拒绝、UNKNOWN付款待核对', `status` VARCHAR(32) NOT NULL DEFAULT 'PENDING' COMMENT 'PENDING待审、SETTLED内部收益结算完成、REJECTED拒绝;APPROVED/PAYING/PAID/UNKNOWN仅历史付款模式',
`payout_no` VARCHAR(64) NULL COMMENT '人工付款授权唯一编号;先同事务进入PAYING并持久化该编号再付款,重试查询原付款,不重新授权', `payout_no` VARCHAR(64) NULL COMMENT '人工付款授权唯一编号;先同事务进入PAYING并持久化该编号再付款,重试查询原付款,不重新授权',
`payment_started_at` DATETIME(3) NULL COMMENT '进入PAYING的服务器本地时间;PAYING或UNKNOWN不能因超时释放来源', `payment_started_at` DATETIME(3) NULL COMMENT '进入PAYING的服务器本地时间;PAYING或UNKNOWN不能因超时释放来源',
`payment_evidence` JSON NULL COMMENT '收款信息、唯一付款凭据和独立核对结果;没有确认不能记已付', `payment_evidence` JSON NULL COMMENT '收款信息、唯一付款凭据和独立核对结果;没有确认不能记已付',
@@ -406,7 +410,7 @@ CREATE TABLE IF NOT EXISTS `rent_settlement` (
UNIQUE KEY `uk_settlement_payment` (`payment_reference`), UNIQUE KEY `uk_settlement_payment` (`payment_reference`),
UNIQUE KEY `uk_settlement_payout` (`payout_no`), UNIQUE KEY `uk_settlement_payout` (`payout_no`),
KEY `idx_settlement_account` (`account_id`,`status`) KEY `idx_settlement_account` (`account_id`,`status`)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='供应商人工结算单;不自动链上出金'; ) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='供应商收益结算;新单转入可用余额,历史单保留付款处理';
-- 供应商订单应收与结算关联;首版每单全额结算一次 -- 供应商订单应收与结算关联;首版每单全额结算一次
CREATE TABLE IF NOT EXISTS `rent_settlement_item` ( CREATE TABLE IF NOT EXISTS `rent_settlement_item` (
+24
View File
@@ -0,0 +1,24 @@
-- MySQL 5.7/8.0:同网络同地址仅允许一笔未终结的地址上链订单。
-- 升级期间暂停下单;不修改历史订单、交易或资金。
DELIMITER $$
DROP PROCEDURE IF EXISTS migrate_rent_onchain_pending$$
CREATE PROCEDURE migrate_rent_onchain_pending()
BEGIN
IF EXISTS (SELECT 1 FROM rent_order
WHERE order_type='ADDRESS_ONCHAIN' AND status NOT IN ('SUCCESS','FAILED','CANCELLED')
GROUP BY network,receiver_address HAVING COUNT(*)>1) THEN
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='Duplicate pending onchain orders: reconcile orders and funds before migration';
END IF;
IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema=DATABASE()
AND table_name='rent_order' AND column_name='onchain_pending_slot') THEN
ALTER TABLE rent_order ADD COLUMN onchain_pending_slot TINYINT GENERATED ALWAYS AS
(CASE WHEN order_type='ADDRESS_ONCHAIN' AND status NOT IN ('SUCCESS','FAILED','CANCELLED') THEN 1 ELSE NULL END);
END IF;
IF NOT EXISTS (SELECT 1 FROM information_schema.statistics WHERE table_schema=DATABASE()
AND table_name='rent_order' AND index_name='uk_order_onchain_pending') THEN
ALTER TABLE rent_order ADD UNIQUE KEY uk_order_onchain_pending(network,receiver_address,onchain_pending_slot);
END IF;
END$$
CALL migrate_rent_onchain_pending()$$
DROP PROCEDURE migrate_rent_onchain_pending$$
DELIMITER ;