From f837befe9909a0280db61f6b22908ccfd87fcdc4 Mon Sep 17 00:00:00 2001 From: luqingjie <544309509@qq.com> Date: Fri, 30 Oct 2026 03:44:03 -0400 Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E5=86=BB=E7=BB=93USDT?= =?UTF-8?q?=EF=BC=8C=E5=90=8C=E4=B8=80=E7=94=A8=E6=88=B7=E5=85=A8=E7=BD=91?= =?UTF-8?q?=E7=BB=9C=E4=BB=85=E5=85=81=E8=AE=B8=E4=B8=80=E7=AC=94=E8=BF=9B?= =?UTF-8?q?=E8=A1=8C=E4=B8=AD=E6=8F=90=E7=8E=B0=E3=80=82=20=E6=94=AF?= =?UTF-8?q?=E6=8C=81=E5=90=8E=E5=8F=B0=E3=80=81Telegram=E5=AE=A1=E6=A0=B8?= =?UTF-8?q?=EF=BC=9B=E6=8B=92=E7=BB=9D=E5=90=8E=E9=87=8A=E6=94=BE=E5=86=BB?= =?UTF-8?q?=E7=BB=93=E3=80=82=20=E6=94=AF=E6=8C=81=E7=AE=A1=E7=90=86?= =?UTF-8?q?=E5=91=98=E5=A1=AB=E5=86=99Hash=E6=A0=B8=E9=AA=8C=E5=88=B0?= =?UTF-8?q?=E8=B4=A6=E3=80=81=E9=93=BE=E4=B8=8A=E7=9B=91=E5=90=AC=E8=87=AA?= =?UTF-8?q?=E5=8A=A8=E5=88=B0=E8=B4=A6=EF=BC=8C=E8=AE=B0=E5=BD=95=E5=88=B0?= =?UTF-8?q?=E8=B4=A6=E6=96=B9=E5=BC=8F=E5=92=8C=E6=93=8D=E4=BD=9C=E6=97=A5?= =?UTF-8?q?=E5=BF=97=E3=80=82=20=E4=B8=A5=E6=A0=BC=E6=A0=B8=E5=AF=B9?= =?UTF-8?q?=E7=BD=91=E7=BB=9C=E3=80=81=E4=BB=98=E6=AC=BE=E6=96=B9=E3=80=81?= =?UTF-8?q?=E6=94=B6=E6=AC=BE=E6=96=B9=E3=80=81=E9=87=91=E9=A2=9D=E5=8F=8A?= =?UTF-8?q?=E5=AE=A1=E6=A0=B8=E5=90=8E=E4=BA=A4=E6=98=93=E6=97=B6=E9=97=B4?= =?UTF-8?q?=EF=BC=8C=E9=98=B2=E6=AD=A2=E9=87=8D=E5=A4=8D=E6=89=A3=E6=AC=BE?= =?UTF-8?q?=E3=80=82=20=E5=B7=B2=E8=A1=A5=E9=BD=90=E5=89=8D=E7=AB=AF?= =?UTF-8?q?=E7=94=B3=E8=AF=B7=E3=80=81=E8=AE=B0=E5=BD=95=E3=80=81=E5=AE=A1?= =?UTF-8?q?=E6=A0=B8=E3=80=81=E6=89=AB=E6=8F=8F=E7=8A=B6=E6=80=81=E5=92=8C?= =?UTF-8?q?=E4=BA=A4=E6=98=93=E6=98=8E=E7=BB=86=E9=A1=B5=E9=9D=A2=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/rental-withdraw.md | 87 ++++ docs/rental/schema-design.md | 2 + .../src/main/resources/application-rental.yml | 14 + .../com/ruoyi/system/rental/RentalChain.java | 3 +- .../com/ruoyi/system/rental/RentalFunds.java | 16 + .../com/ruoyi/system/rental/RentalStore.java | 3 + .../system/rental/RentalWithdrawChain.java | 139 ++++++ .../rental/RentalWithdrawController.java | 79 ++++ .../system/rental/RentalWithdrawScanner.java | 129 +++++ .../system/rental/RentalWithdrawals.java | 444 ++++++++++++++++++ .../system/service/TelegramAuditService.java | 41 +- .../rental/RentalWithdrawChainTest.java | 75 +++ .../system/rental/RentalWithdrawTest.java | 290 ++++++++++++ sql/rent_init.sql | 83 ++++ sql/rent_withdraw_menu.sql | 28 ++ sql/rent_withdraw_migration.sql | 94 ++++ sql/rent_withdraw_tables.sql | 81 ++++ 17 files changed, 1604 insertions(+), 4 deletions(-) create mode 100644 docs/rental-withdraw.md create mode 100644 ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawChain.java create mode 100644 ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawController.java create mode 100644 ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawScanner.java create mode 100644 ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawals.java create mode 100644 ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawChainTest.java create mode 100644 ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawTest.java create mode 100644 sql/rent_withdraw_menu.sql create mode 100644 sql/rent_withdraw_migration.sql create mode 100644 sql/rent_withdraw_tables.sql diff --git a/docs/rental-withdraw.md b/docs/rental-withdraw.md new file mode 100644 index 0000000..b9acf00 --- /dev/null +++ b/docs/rental-withdraw.md @@ -0,0 +1,87 @@ +# 租赁资金账户提现 + +## 业务边界 + +提现只使用当前用户对应网络 `rent_account.available_amount`,不提取冻结余额或供应商待结算金额。NILE与MAINNET分别记账,但数据库用 `active_user_id` 唯一槽保证同一用户全网络只能有一笔未完成提现。提交即在同一事务写 `WITHDRAW_HOLD` 流水:可用余额减少、冻结余额增加。拒绝写 `WITHDRAW_RELEASE`;链上到账写 `WITHDRAW_COMPLETE`,只减少冻结,不再次减少可用。 + +状态为 `PENDING_REVIEW → EXECUTING → VERIFYING/MANUAL_REVIEW → COMPLETED`,拒绝为 `REJECTED`。进入执行后不能直接退款,因为管理员可能已经付款;RPC失败、未确认或证据冲突均保持冻结。 + +后台和Telegram审核调用相同服务。Telegram数字ID除原白名单外,还必须在 `telegram-reviewers` 映射到具有 `rent:withdraw:review` 权限且有效的系统用户,不能用昵称授权或虚构系统操作者。审核通过保存当时的付款地址JSON快照,后续修改配置不改变已审核订单。 + +## 手动与自动到账 + +管理员手动:完成外部钱包付款后填写交易Hash、可选日志索引和执行备注。系统独立查询TRON交易及收据,核验成功才能到账,不能强制改变余额。 + +自动监听:按网络持久化扫描已固化区块,RPC确认深度由 `rental.confirmations` 再次限制。逐块读取完整交易收据,发现审核快照付款地址发出的真实USDT `Transfer`,保存 `rent_withdraw_transaction` 后匹配提现。匹配同时要求网络、USDT合约、付款地址、收款地址、6位金额完全相同,并且链上区块时间严格晚于 `approved_at`。不拼接多笔、不接受多付少付;多单歧义转人工核对。 + +两种入口最终调用同一个 `complete` 事务。提现单行锁、链上事件唯一键、`withdraw_id`唯一认领及账本business_key共同防止并发重复扣款。到账记录 `arrival_mode=MANUAL/AUTO`、Hash、日志索引、区块与时间。自动扫描游标仅在整块事件保存完成后推进,多实例使用短租约;故障重启会重扫,幂等约束防重复。 + +## 部署 + +1. 执行 `sql/rent_withdraw_migration.sql`,再执行 `sql/rent_withdraw_menu.sql`;不删除或重算历史余额。 +2. 配置每个启用网络的付款地址、额度、Telegram映射;先保持 `enabled=false` 和 `scan-enabled=false`。 +3. 部署前后端,赋予运营角色 `rent:withdraw:list/review/execute`;申请角色由脚本获得 `rent:withdraw:create`。 +4. 打开提现但暂不开扫描,使用小额单验证后台审核及人工Hash核验。 +5. 验证RPC支持 `/wallet/gettransactioninfobyblocknum` 后开启扫描,观察后台页面游标和服务日志,再扩大额度。 + +```yaml +rental: + withdraw: + enabled: ${RENT_WITHDRAW_ENABLED:false} + min-amount-usdt: ${RENT_WITHDRAW_MIN_USDT:1} + max-amount-usdt: ${RENT_WITHDRAW_MAX_USDT:10000} + scan-enabled: ${RENT_WITHDRAW_SCAN_ENABLED:false} + poll-interval-ms: ${RENT_WITHDRAW_POLL_MS:10000} + scan-batch-blocks: ${RENT_WITHDRAW_SCAN_BATCH_BLOCKS:5} + telegram-reviewers: ${RENT_WITHDRAW_TELEGRAM_REVIEWERS:} + nile: + payout-addresses: ${RENT_WITHDRAW_NILE_PAYOUT_ADDRESSES:} + mainnet: + payout-addresses: ${RENT_WITHDRAW_MAINNET_PAYOUT_ADDRESSES:} +``` + +服务不保存付款私钥、不自动广播。配置多个地址用英文逗号分隔;地址与Telegram映射属于敏感运营配置,不提交代码仓库。日志打印提现ID、网络、金额、Hash、日志索引、模式和脱敏异常定位,不打印凭证、私钥、签名原文或完整RPC响应。 + +## 页面及接口 + +本人资金账户页提供申请、记录和时间线:`POST /rental/withdraw/create`、`GET /rental/withdraw/list`、`GET /rental/withdraw/{id}`。管理员菜单页面使用 `/rental/manage/withdraw` 下的列表、详情、审核及transaction接口;只读交易明细接口便于定位未匹配事件。用户ID始终来自登录上下文。 + +申请示例(使用已登录后台身份,不使用租赁应用API凭证): + +```json +{"network":"NILE","receiver_address":"你的TRON地址","amount":"30.000000","client_request_no":"客户端唯一请求号","remark":"提现说明"} +``` + +`client_request_no`重试必须保持不变。相同用户与请求号、相同内容返回原申请;变更金额或地址需要新请求号,并且原在途申请必须先结束。金额以十进制字符串传递,最多6位小数;初版不收提现手续费,申请金额等于链上应付USDT金额。 + +管理员审核:`POST /rental/manage/withdraw/{id}/review`,请求 `{"approve":true,"reason":"审核意见"}`。手动到账:`POST /rental/manage/withdraw/{id}/transaction`,请求 `{"transaction_id":"64位Hash","log_index":0,"remark":"付款执行说明"}`;日志索引可省略,但同一交易存在多个符合条件的事件时必须明确指定。核验未通过时返回保留冻结的当前状态及`last_error`,前端不得仅根据HTTP成功提示到账。 + +交易排查:`GET /rental/manage/withdraw/transactions?network=NILE&page=1&hash=可选完整Hash`。本人列表固定每页20条,管理员列表支持network/status/page;本人详情禁止跨用户访问。相同区块发现多笔符合单张提现申请的付款时转人工核对,不自动选择第一笔。 + +## 数据表职责 + +| 表 | 关键字段与职责 | +| --- | --- | +| rent_withdraw_order | user_id/account_id/network确定资金归属;amount/frozen_amount记录申请与冻结金额;active_user_id唯一约束防全网络重复申请;client_request_no/request_hash保证重试幂等;approved_at与payout_sender_snapshot固定匹配边界;arrival_mode/arrival_transaction_id/completed_at记录到账结果 | +| rent_withdraw_transaction | network+transaction_id+log_index唯一标识真实链上事件;保存合约、付款方、收款方、6位USDT金额、最小单位、区块Hash/时间和证据;withdraw_id唯一约束防止一笔付款核销两次 | +| rent_withdraw_scan_cursor | 每网络一个持久扫描位置,last_block只在整块处理成功后推进;lock_owner/lock_until支持多实例租约;last_error记录可排查故障 | +| rent_ledger | 新增nullable withdraw_id关联提现;WITHDRAW_HOLD/RELEASE/COMPLETE与余额更新同事务,不更改既有充值和租赁流水 | +| rent_event | 保存申请、审核、手动核验、MANUAL/AUTO到账操作轨迹和操作者 | +| telegram_audit_record及推送队列 | 沿用项目现有Telegram审核模型,业务类型RENT_WITHDRAW;创建申请时与冻结一并持久化,机器人推送失败不丢审核单 | + +## 排查及运行边界 + +管理员详情突出展示本单网络的允许付款钱包,并在通过审核前再次确认网络、付款地址、收款地址与金额。待审核使用当前配置,通过后展示审核时的地址快照;地址未配置或详情未加载完成时禁止点击通过。提示同时适用于后续手动Hash核验与自动到账。 + +按withdrawId/withdrawNo、network、Hash检索日志;扫描日志包含cursor、confirmedHead及backlog。余额不足、重复申请、本人审核、权限映射无效均拒绝;网络异常、未确认、付款方/金额不匹配均不解冻。管理员不能审核自己的提现。 + +首次扫描从最早有效审核时间前定位区块,之后按持久断点追赶。默认每10秒最多扫描5块,积压时可调大batch(上限100),并观察RPC限流。RPC必须支持整块回执接口,不支持或回执缺失时停止推进并保留冻结;不会降级成忽略交易。服务使用已有TRON网络配置和对应USDT合约,不能把测试网交易用于主网到账。 + +增量脚本需先于新服务执行,因为公共账本插入已包含withdraw_id。脚本仅新增结构和菜单,不会付款、不重算余额、不删除历史数据。真实MySQL、Telegram机器人及NILE钱包仍需部署后小额联调。 + +## 本地验证记录 + +- JDK8执行`Rental*Test`:108项通过,0失败、0错误,其中提现专项12项。 +- 覆盖冻结/拒绝释放、跨网络并发申请、幂等重试、手动与自动并发核销、未知链上结果保留冻结、重复付款歧义、Telegram真实审核路由和重复回调、RPC失败后恢复,以及真实USDT日志解码和确认边界。 +- 前端staging构建完成;存在项目原有的3个API导出缺失告警以及资源体积告警。提现相关Vue模板与脚本解析通过。 +- 新建表在初始化、独立建表和增量脚本中的定义一致。数据库测试使用H2 MySQL兼容模式,未执行生产MySQL脚本,未发送Telegram消息或广播交易。 diff --git a/docs/rental/schema-design.md b/docs/rental/schema-design.md index 4fded6b..4ae1244 100644 --- a/docs/rental/schema-design.md +++ b/docs/rental/schema-design.md @@ -2,6 +2,8 @@ 2026-10-29扩展:新增地址上链订单ADDRESS_ONCHAIN,供应商固定转1TRX,用户USDT账户承担本金折价及服务费;复用订单、任务、交易及账务,新增字段和节点能力见 [地址上链完整设计与实现](../rental-address-onchain.md)。该类型不绑定套餐、不做资源换算、无租期及回收;原有资源租赁规则保持本基线。 +资金账户新增可用USDT提现:申请冻结、后台/Telegram审核、管理员Hash核验及链上监听自动到账,完整表、状态、配置及部署见 [租赁资金账户提现](../rental-withdraw.md)。提现不保存付款私钥、不自动广播,所有到账均以已确认USDT Transfer为依据。 + 2026-10-25增量:新增第17张表 rent_user_package,按系统用户绑定套餐与默认项;下单从应用user_id确定授权,见 [用户套餐绑定](user-package-bindings.md)。以下16表描述为原设计基线。 状态:V2.2设计基线;当前已新增后端、Vue及本地Node.js Agent实现,运行配置、接口与验证边界见[三端实现说明](implementation.md)。未执行现有数据库迁移或真实链上广播。当前权威 DDL 为 [rent_init.sql](../../sql/rent_init.sql),共16张表;历史设计复核见[业务复核与修正说明](business-review-v2.2.md),逐表说明见[table-functional-flows.md](table-functional-flows.md)。下文“本次仅设计”描述设计审查阶段,不替代当前实现记录。 diff --git a/ruoyi-admin/src/main/resources/application-rental.yml b/ruoyi-admin/src/main/resources/application-rental.yml index f212c59..721baa7 100644 --- a/ruoyi-admin/src/main/resources/application-rental.yml +++ b/ruoyi-admin/src/main/resources/application-rental.yml @@ -50,6 +50,20 @@ rental: # 充值地址仅供USDT入金,与供应商转出1TRX的钱包无关。 nile: ${RENT_NILE_DEPOSIT:TSeHZVEWQaCcWQrxevbt9LQfb1YC53ww8a} mainnet: ${RENT_MAINNET_DEPOSIT:TSeHZVEWQaCcWQrxevbt9LQfb1YC53ww8a} + # 提现不自动广播:管理员付款后由人工Hash核验或已确认区块扫描完成到账。 + withdraw: + enabled: ${RENT_WITHDRAW_ENABLED:false} + min-amount-usdt: ${RENT_WITHDRAW_MIN_USDT:1} + max-amount-usdt: ${RENT_WITHDRAW_MAX_USDT:10000} + scan-enabled: ${RENT_WITHDRAW_SCAN_ENABLED:false} + poll-interval-ms: ${RENT_WITHDRAW_POLL_MS:10000} + scan-batch-blocks: ${RENT_WITHDRAW_SCAN_BATCH_BLOCKS:5} + # 格式:Telegram数字ID:系统审核员userId,多项逗号分隔;同时校验Telegram白名单及后台审核权限。 哪些Telegram用户对应哪些后台审核员"123456789:99,987654321:100" + telegram-reviewers: ${RENT_WITHDRAW_TELEGRAM_REVIEWERS:} + nile: + payout-addresses: ${RENT_WITHDRAW_NILE_PAYOUT_ADDRESSES:} + mainnet: + payout-addresses: ${RENT_WITHDRAW_MAINNET_PAYOUT_ADDRESSES:} # 地址上链:固定转1TRX;本金折价+固定服务费从用户USDT账户冻结,确认后扣款。 # 默认关闭;两个网络的价格必须分别填写,不自动使用外部行情或跨网络兜底。 address-onchain: diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java index 0eb734a..f7db426 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalChain.java @@ -80,7 +80,8 @@ public class RentalChain { json.writeValueAsString(body))) .build(); try (Response response = client.newCall(request).execute()) { - boolean fullBlock = path.endsWith("/getnowblock") || path.endsWith("/getblockbynum"); + boolean fullBlock = path.endsWith("/getnowblock") || path.endsWith("/getblockbynum") + || path.endsWith("/gettransactioninfobyblocknum"); return json.readTree(RentalHttp.body(response, (fullBlock ? 16 : 1) * 1024 * 1024)); } diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalFunds.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalFunds.java index 13de493..307d001 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalFunds.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalFunds.java @@ -54,6 +54,20 @@ public class RentalFunds { long actor, String evidence, String reason) { + post(account, key, type, available, frozen, pending, fee, order, settlement, refund, + actor, evidence, reason, null); + } + + /** 提现独立关联;与租赁冻结复用同一账户行锁、余额检查及不可变流水。 */ + public void withdraw(long account, long withdraw, String type, BigDecimal available, + BigDecimal frozen, long actor, String reason) { + post(account, type + ":" + withdraw, type, available, frozen, ZERO, ZERO, + null, null, null, actor, null, reason, withdraw); + } + + private void post(long account, String key, String type, BigDecimal available, BigDecimal frozen, + BigDecimal pending, BigDecimal fee, Long order, Long settlement, Long refund, + long actor, String evidence, String reason, Long withdraw) { Map row = store.get("account", account, true); Map old = store.one("SELECT * FROM rent_ledger WHERE business_key=?", key); if (old != null) { @@ -113,6 +127,8 @@ public class RentalFunds { settlement, "refund_id", refund, + "withdraw_id", + withdraw, "reversal_of_id", reversalOf, "operator_user_id", diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalStore.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalStore.java index 2cebd9a..92def11 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalStore.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalStore.java @@ -26,6 +26,9 @@ public class RentalStore { "user_package", "account", "topup_order", + "withdraw_order", + "withdraw_transaction", + "withdraw_scan_cursor", "order", "task", "transaction", diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawChain.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawChain.java new file mode 100644 index 0000000..0c3f06e --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawChain.java @@ -0,0 +1,139 @@ +package com.ruoyi.system.rental; + +import static com.ruoyi.system.rental.RentalValues.*; + +import com.fasterxml.jackson.databind.JsonNode; +import com.ruoyi.system.service.TronServiceProvider; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.tron.trident.core.ApiWrapper; +import org.tron.trident.utils.Base58Check; + +/** + * 提现只读链上适配器。不持有私钥、不广播;仅返回当前网络真实USDT合约的成功且足够确认的Transfer事件。 + * RPC/证据缺失抛出异常,调用方保留冻结与扫描断点,不能将未知结果解释为付款失败。 + */ +@Service +public class RentalWithdrawChain { + private static final String TRANSFER_TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"; + private final RentalChain chain; + private final TronServiceProvider services; + @Value("${rental.confirmations:19}") + private long confirmations; + + public RentalWithdrawChain(RentalChain chain, TronServiceProvider services) { + this.chain = chain; + this.services = services; + } + + /** 已固化区块上再保留配置确认深度,与既有租赁核验口径一致。 */ + public long confirmedHead(String network) { + long height = chain.call(network(network), "/walletsolidity/getnowblock", map()) + .path("block_header").path("raw_data").path("number").asLong(-1); + require(height >= 0 && confirmations > 0, "提现链头或确认深度无效"); + return Math.max(0, height - confirmations + 1); + } + + public JsonNode block(String network, long height) { + JsonNode result = chain.call(network, "/wallet/getblockbynum", map("num", height)); + require(result.path("block_header").path("raw_data").path("number").asLong(-1) == height, + "提现扫描区块尚不可用"); + return result; + } + + public String contract(String network) { + return services.getServiceForNetwork(network(network)).contractAddress(); + } + + /** 一次获取整块回执,覆盖合约内部USDT转账,不能只筛选顶层调用USDT的交易。 */ + public JsonNode receipts(String network, long height) { + JsonNode result = chain.call(network, "/wallet/gettransactioninfobyblocknum", map("num", height)); + require(result.isArray(), "提现区块回执接口不可用,保留扫描断点"); + return result; + } + + public boolean relevantLog(String network, JsonNode log, java.util.Set senders) { + if (!hex(contract(network)).substring(2).equalsIgnoreCase(log.path("address").asText()) + || log.path("topics").size() != 3 + || !TRANSFER_TOPIC.equalsIgnoreCase(log.path("topics").get(0).asText())) { + return false; + } + return senders.contains(topicAddress(log.path("topics").get(1).asText())); + } + + /** 扫描预筛仅降低RPC量,最终仍以收据中的真实Transfer日志为准。 */ + public boolean isUsdtCall(String network, JsonNode transaction) { + for (JsonNode item : transaction.path("raw_data").path("contract")) { + if ("TriggerSmartContract".equals(item.path("type").asText()) + && hex(contract(network)).equalsIgnoreCase(item.path("parameter").path("value") + .path("contract_address").asText())) { + return true; + } + } + return false; + } + + public List> events(String network, String hash) { + network(network); + require(hash != null && hash.matches("[0-9a-fA-F]{64}"), "提现交易Hash必须为64位十六进制"); + hash = hash.toLowerCase(Locale.ROOT); + JsonNode receipt = chain.call(network, "/walletsolidity/gettransactioninfobyid", map("value", hash)); + long height = receipt.path("blockNumber").asLong(-1); + require(height >= 0 && height <= confirmedHead(network) + && hash.equalsIgnoreCase(receipt.path("id").asText()), "提现交易尚未确认或回执不完整"); + List> result = new ArrayList<>(); + // 失败交易不会产生有效付款;不认领任何事件,资金仍保持冻结。 + if ("FAILED".equals(receipt.path("result").asText()) + || !"SUCCESS".equals(receipt.path("receipt").path("result").asText("SUCCESS"))) { + return result; + } + JsonNode transaction = chain.call(network, "/wallet/gettransactionbyid", map("value", hash)); + require(hash.equalsIgnoreCase(transaction.path("txID").asText()) && transaction.path("ret").size() > 0 + && "SUCCESS".equals(transaction.path("ret").get(0).path("contractRet").asText()), + "提现原交易执行结果无效"); + JsonNode containingBlock = block(network, height); + long timestamp = containingBlock.path("block_header").path("raw_data").path("timestamp").asLong(-1); + require(timestamp > 0 && timestamp == receipt.path("blockTimeStamp").asLong(-1), "提现区块时间证据不一致"); + JsonNode logs = receipt.path("log"); + require(logs.isArray() && logs.size() <= 512, "提现交易日志缺失或过多"); + String token = contract(network); + for (int index = 0; index < logs.size(); index++) { + JsonNode entry = logs.get(index); + if (!hex(token).substring(2).equalsIgnoreCase(entry.path("address").asText()) + || entry.path("topics").size() != 3 + || !TRANSFER_TOPIC.equalsIgnoreCase(entry.path("topics").get(0).asText())) { + continue; + } + String rawAmount = entry.path("data").asText(); + require(rawAmount.matches("[0-9a-fA-F]{64}"), "提现Transfer金额编码错误"); + BigInteger units = new BigInteger(rawAmount, 16); + // DECIMAL(65)足以覆盖正常USDT金额,异常合约数据不能导致静默截断。 + require(units.toString().length() <= 59, "提现Transfer金额超出存储范围"); + result.add(map("network", network, "transaction_id", hash, "log_index", index, + "token_contract", token, "from_address", topicAddress(entry.path("topics").get(1).asText()), + "to_address", topicAddress(entry.path("topics").get(2).asText()), "amount_units", units, + "amount_usdt", new BigDecimal(units).movePointLeft(6).setScale(6), "block_number", height, + "block_hash", containingBlock.path("blockID").asText(), "block_time", + LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC))); + } + return result; + } + + private String hex(String address) { + return ApiWrapper.toHex(ApiWrapper.parseAddress(address)); + } + + private String topicAddress(String topic) { + require(topic.matches("(?i)0{24}[0-9a-f]{40}"), "提现Transfer地址编码错误"); + return Base58Check.bytesToBase58(org.bouncycastle.util.encoders.Hex.decode("41" + topic.substring(24))); + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawController.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawController.java new file mode 100644 index 0000000..d804b59 --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawController.java @@ -0,0 +1,79 @@ +package com.ruoyi.system.rental; + +import static com.ruoyi.system.rental.RentalValues.*; + +import com.ruoyi.common.core.domain.AjaxResult; +import com.ruoyi.common.utils.SecurityUtils; +import com.ruoyi.system.service.TelegramAuditService; +import java.util.Map; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +/** 提现本人入口与管理员入口分离,用户ID始终取登录上下文,不能通过请求指定。 */ +@RestController +public class RentalWithdrawController { + private final RentalWithdrawals withdrawals; + private final TelegramAuditService telegram; + + public RentalWithdrawController(RentalWithdrawals withdrawals, TelegramAuditService telegram) { + this.withdrawals = withdrawals; + this.telegram = telegram; + } + + @PostMapping("/rental/withdraw/create") + @PreAuthorize("@ss.hasPermi('rent:withdraw:create')") + public AjaxResult create(@RequestBody Map body) { + return AjaxResult.success(withdrawals.create(SecurityUtils.getUserId(), body)); + } + + @GetMapping("/rental/withdraw/list") + @PreAuthorize("@ss.hasPermi('rent:portal:view')") + public AjaxResult list(@RequestParam String network, @RequestParam(defaultValue = "1") int page) { + return AjaxResult.success(withdrawals.list(SecurityUtils.getUserId(), network, "", page, false)); + } + + @GetMapping("/rental/withdraw/{id}") + @PreAuthorize("@ss.hasPermi('rent:portal:view')") + public AjaxResult detail(@PathVariable long id) { + return AjaxResult.success(withdrawals.detail(SecurityUtils.getUserId(), id, false)); + } + + @GetMapping("/rental/manage/withdraw/list") + @PreAuthorize("@ss.hasPermi('rent:withdraw:list')") + public AjaxResult manageList(@RequestParam String network, @RequestParam(defaultValue = "") String status, + @RequestParam(defaultValue = "1") int page) { + return AjaxResult.success(withdrawals.list(0, network, status, page, true)); + } + + @GetMapping("/rental/manage/withdraw/{id}") + @PreAuthorize("@ss.hasPermi('rent:withdraw:list')") + public AjaxResult manageDetail(@PathVariable long id) { + return AjaxResult.success(withdrawals.detail(0, id, true)); + } + + @GetMapping("/rental/manage/withdraw/transactions") + @PreAuthorize("@ss.hasPermi('rent:withdraw:list')") + public AjaxResult transactions(@RequestParam String network, @RequestParam(defaultValue = "") String hash, + @RequestParam(defaultValue = "1") int page) { + return AjaxResult.success(withdrawals.transactions(network, hash, page)); + } + + @PostMapping("/rental/manage/withdraw/{id}/review") + @PreAuthorize("@ss.hasPermi('rent:withdraw:review')") + public AjaxResult review(@PathVariable long id, @RequestBody Map body) { + require(body.get("approve") instanceof Boolean, "approve必须为布尔值"); + telegram.reviewRentalWithdrawFromBackoffice(id, Boolean.TRUE.equals(body.get("approve")), input(body, "reason", 512)); + return AjaxResult.success(); + } + + @PostMapping("/rental/manage/withdraw/{id}/transaction") + @PreAuthorize("@ss.hasPermi('rent:withdraw:execute')") + public AjaxResult transaction(@PathVariable long id, @RequestBody Map body) { + return AjaxResult.success(withdrawals.manual(id, body, SecurityUtils.getUserId())); + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawScanner.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawScanner.java new file mode 100644 index 0000000..2a5a647 --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawScanner.java @@ -0,0 +1,129 @@ +package com.ruoyi.system.rental; + +import static com.ruoyi.system.rental.RentalValues.*; + +import com.fasterxml.jackson.databind.JsonNode; +import java.util.HashSet; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import lombok.extern.slf4j.Slf4j; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.core.env.Environment; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; + +/** + * 提现自动到账扫描。已确认区块按持久游标读取,先保存全部相关事件再推进断点。 + * 多实例使用短租约和owner条件更新;RPC异常/进程退出后重扫,事件与资金流水唯一键保证幂等。 + */ +@Slf4j +@Component +@ConditionalOnProperty(name = "rental.enabled", havingValue = "true") +public class RentalWithdrawScanner { + private final RentalStore store; + private final RentalWithdrawals withdrawals; + private final RentalWithdrawChain chain; + private final Environment environment; + + public RentalWithdrawScanner(RentalStore store, RentalWithdrawals withdrawals, + RentalWithdrawChain chain, Environment environment) { + this.store = store; + this.withdrawals = withdrawals; + this.chain = chain; + this.environment = environment; + } + + @Scheduled(fixedDelayString = "${rental.withdraw.poll-interval-ms:10000}") + public void tick() { + if (!environment.getProperty("rental.withdraw.scan-enabled", Boolean.class, false)) { return; } + for (String network : new String[] {"NILE", "MAINNET"}) { + try { scan(network); } + catch (Exception ex) { + store.execute("UPDATE rent_withdraw_scan_cursor SET last_error=?,updated_at=? WHERE network=?", + "扫描尚未完成,请检查RPC及服务日志,资金继续冻结", now(), network); + log.warn("提现自动扫描待重试 network={} diagnostic={}", network, RentalDiagnostics.describe(ex)); + } + } + } + + public void scan(String network) { + List> orders = store.rows("SELECT * FROM rent_withdraw_order WHERE network=?" + + " AND status IN ('EXECUTING','VERIFYING','MANUAL_REVIEW') ORDER BY approved_at,id", network); + if (orders.isEmpty()) { return; } + long head = chain.confirmedHead(network); + Map cursor = store.one("SELECT * FROM rent_withdraw_scan_cursor WHERE network=?", network); + if (cursor == null) { + // 首次启动二分定位最早审批时间之前的区块,不从当前链头开始导致停机付款遗漏。 + long first = beforeApproval(network, head, time(orders.get(0).get("approved_at")).toEpochMilli()); + store.execute("INSERT INTO rent_withdraw_scan_cursor(network,last_block,version,created_at,updated_at)" + + " VALUES(?,?,0,?,?) ON DUPLICATE KEY UPDATE network=network", network, Math.max(-1, first - 1), now(), now()); + } + String lease = id("WS"); + if (store.execute("UPDATE rent_withdraw_scan_cursor SET lock_owner=?,lock_until=?,updated_at=?" + + " WHERE network=? AND (lock_until IS NULL OR lock_until allowed = new HashSet<>(withdrawals.senders(network)); + for (Map order : orders) { allowed.addAll(withdrawals.snapshotSenders(order)); } + for (int count = 0; count < batch && last < head; count++) { + require(store.execute("UPDATE rent_withdraw_scan_cursor SET lock_until=? WHERE network=? AND lock_owner=? AND lock_until>?", + after(120), network, lease, now()) == 1, "提现扫描租约已失效"); + long height = last + 1; + JsonNode block = chain.block(network, height); + JsonNode receipts = chain.receipts(network, height); + // 预先核对所有智能合约交易均有回执,不能把节点返回的部分回执当成完整区块推进游标。 + Set available = new HashSet<>(); + for (JsonNode receipt : receipts) { available.add(receipt.path("id").asText()); } + for (JsonNode transaction : block.path("transactions")) { + for (JsonNode contract : transaction.path("raw_data").path("contract")) { + if ("TriggerSmartContract".equals(contract.path("type").asText())) { + require(available.contains(transaction.path("txID").asText()), "提现扫描区块回执不完整"); + } + } + } + List eventIds = new ArrayList<>(); + for (JsonNode receipt : receipts) { + boolean relevant = false; + for (JsonNode entry : receipt.path("log")) { + if (chain.relevantLog(network, entry, allowed)) { relevant = true; break; } + } + if (!relevant) { continue; } + for (Map event : chain.events(network, receipt.path("id").asText())) { + if (allowed.contains(text(event, "from_address"))) { + long eventId = withdrawals.record(event, "SCAN"); + eventIds.add(eventId); + log.debug("提现扫描事件 network={} block={} hash={} logIndex={} eventId={}", + network, height, event.get("transaction_id"), event.get("log_index"), eventId); + } + } + } + // 整块证据先落库,再匹配,避免同一块内多笔相同付款被错误地先到先得。 + for (Long eventId : eventIds) { withdrawals.autoMatch(eventId); } + require(store.execute("UPDATE rent_withdraw_scan_cursor SET last_block=?,last_error=NULL,updated_at=?" + + " WHERE network=? AND lock_owner=? AND last_block=? AND lock_until>?", + height, now(), network, lease, last, now()) == 1, "提现扫描断点更新冲突,下次重扫"); + last = height; + } + store.execute("UPDATE rent_withdraw_order SET last_check_at=? WHERE network=? AND status IN ('EXECUTING','VERIFYING','MANUAL_REVIEW')", now(), network); + log.debug("提现扫描完成 network={} cursor={} confirmedHead={} backlog={}", network, last, head, head - last); + } finally { + store.execute("UPDATE rent_withdraw_scan_cursor SET lock_owner=NULL,lock_until=NULL WHERE network=? AND lock_owner=?", network, lease); + } + } + + private long beforeApproval(String network, long head, long approvedAt) { + long low = 0; + long high = head; + while (low < high) { + long middle = low + (high - low + 1) / 2; + long timestamp = chain.block(network, middle).path("block_header").path("raw_data").path("timestamp").asLong(-1); + require(timestamp > 0, "提现扫描定位缺少区块时间"); + if (timestamp < approvedAt) { low = middle; } else { high = middle - 1; } + } + return low; + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawals.java b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawals.java new file mode 100644 index 0000000..5c66c59 --- /dev/null +++ b/ruoyi-system/src/main/java/com/ruoyi/system/rental/RentalWithdrawals.java @@ -0,0 +1,444 @@ +package com.ruoyi.system.rental; + +import static com.ruoyi.system.rental.RentalValues.*; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.ruoyi.system.domain.TelegramAuditRecord; +import com.ruoyi.system.mapper.TelegramAuditMapper; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Objects; +import lombok.extern.slf4j.Slf4j; +import org.springframework.core.env.Environment; +import org.springframework.dao.DuplicateKeyException; +import org.springframework.stereotype.Service; +import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.support.TransactionTemplate; + +/** + * 租赁提现唯一业务入口。RPC与数据库事务分离;资金状态以提现单行锁保护。 + * 人工和自动完成复用同一事务,未知链上结果绝不释放冻结,不提供直接改余额/强制到账接口。 + */ +@Slf4j +@Service +public class RentalWithdrawals { + public static final String TELEGRAM_TYPE = "RENT_WITHDRAW"; + private static final List EXECUTABLE = Arrays.asList("EXECUTING", "VERIFYING", "MANUAL_REVIEW"); + private final RentalStore store; + private final RentalFunds funds; + private final RentalWithdrawChain chain; + private final Environment environment; + private final ObjectMapper json; + private final TelegramAuditMapper telegram; + private final TransactionTemplate transactions; + + public RentalWithdrawals(RentalStore store, RentalFunds funds, RentalWithdrawChain chain, + Environment environment, ObjectMapper json, TelegramAuditMapper telegram, + PlatformTransactionManager manager) { + this.store = store; + this.funds = funds; + this.chain = chain; + this.environment = environment; + this.json = json; + this.telegram = telegram; + this.transactions = new TransactionTemplate(manager); + } + + public boolean enabled() { + return environment.getProperty("rental.enabled", Boolean.class, false) + && environment.getProperty("rental.withdraw.enabled", Boolean.class, false); + } + + /** 余额与申请同事务提交;唯一active_user_id保证跨网络也只能有一笔进行中的提现。 */ + public Map create(long user, Map request) { + String network = network(input(request, "network", 16)); + String receiver = input(request, "receiver_address", 64); + RentalOrders.address(receiver); + String requestNo = input(request, "client_request_no", 64); + BigDecimal value = amount(request, "amount"); + require(value.signum() > 0 && value.precision() <= 30, "提现金额须为正数且最多6位小数"); + String remark = optional(request, "remark"); + String hash = RentalCrypto.sha256(encode(map("network", network, "receiver", receiver, + "amount", value.toPlainString(), "remark", remark))); + log.info("提现申请检查 userId={} network={} amountUsdt={} requestNo={} enabled={}", + user, network, value, requestNo, enabled()); + try { + return transactions.execute(status -> { + Map existing = store.one("SELECT * FROM rent_withdraw_order WHERE user_id=? AND client_request_no=?", user, requestNo); + if (existing != null) { + require(hash.equals(text(existing, "request_hash")), "提现重复请求参数不一致"); + log.info("提现申请幂等命中 userId={} withdrawId={} requestNo={}", user, existing.get("id"), requestNo); + return view(existing); + } + require(enabled(), "租赁提现暂未开启"); + BigDecimal minimum = new BigDecimal(environment.getProperty("rental.withdraw.min-amount-usdt", "1")); + BigDecimal maximum = new BigDecimal(environment.getProperty("rental.withdraw.max-amount-usdt", "10000")); + require(minimum.signum() > 0 && maximum.compareTo(minimum) >= 0 + && value.compareTo(minimum) >= 0 && value.compareTo(maximum) <= 0, "提现金额不在配置的允许范围内"); + require(!senders(network).isEmpty(), "当前网络未配置提现付款地址"); + require(store.one("SELECT id FROM rent_withdraw_order WHERE active_user_id=?", user) == null, + "您已有一笔正在处理的提现,请先查看原提现单"); + Map account = store.one("SELECT * FROM rent_account WHERE user_id=? AND network=? FOR UPDATE", user, network); + require(account != null && "ACTIVE".equals(text(account, "status")), "资金账户不存在或已冻结"); + require(amount(account, "available_amount").compareTo(value) >= 0, "账户可用USDT余额不足"); + long id = store.insert("withdraw_order", map("withdraw_no", id("RW"), "user_id", user, + "account_id", account.get("id"), "network", network, "client_request_no", requestNo, + "request_hash", hash, "receiver_address", receiver, "amount", value, "frozen_amount", value, + "status", "PENDING_REVIEW", "active_user_id", user, "remark", remark)); + funds.withdraw(number(account, "id"), id, "WITHDRAW_HOLD", value.negate(), value, user, "申请提现冻结USDT"); + Map order = store.get("withdraw_order", id, false); + // 与提现同事务落持久审核队列,避免提交后进程退出导致永久漏推。 + createTelegramAudit(order); + store.event("WITHDRAW", id, "CREATE", user, "申请提现并冻结USDT"); + log.info("提现申请成功 withdrawId={} withdrawNo={} userId={} accountId={} network={} amountUsdt={}", + id, order.get("withdraw_no"), user, account.get("id"), network, value); + return view(order); + }); + } catch (DuplicateKeyException ex) { + Map old = store.one("SELECT * FROM rent_withdraw_order WHERE user_id=? AND client_request_no=?", user, requestNo); + if (old != null && hash.equals(text(old, "request_hash"))) { + return view(old); + } + log.warn("提现并发申请冲突 userId={} network={} requestNo={}", user, network, requestNo); + throw new IllegalArgumentException("已有进行中的提现或重复请求参数冲突,请刷新提现记录"); + } catch (RuntimeException ex) { + log.warn("提现申请未完成 userId={} network={} requestNo={} diagnostic={}", + user, network, requestNo, RentalDiagnostics.describe(ex)); + throw ex; + } + } + + /** 两个渠道都调用此方法;后台入口负责同步Telegram审核单,Telegram入口在原审核事务内完成。 */ + public void review(long id, boolean approve, long actor, String channel, String telegramId, String reason) { + require(Arrays.asList("BACKOFFICE", "TELEGRAM").contains(channel), "审核渠道无效"); + require(reason != null && !reason.trim().isEmpty() && reason.length() <= 512, "请填写审核意见,最多512字"); + transactions.execute(status -> { + Map order = store.get("withdraw_order", id, true); + require(actor > 0 && number(order, "user_id") != actor, "不能审核自己的提现申请"); + require("PENDING_REVIEW".equals(text(order, "status")), "提现已审核,请刷新查看处理结果"); + Map changes = map("status", approve ? "EXECUTING" : "REJECTED", + "review_channel", channel, "reviewer_user_id", actor, "reviewer_telegram_id", telegramId, + "review_reason", reason.trim(), "reviewed_at", now()); + if (approve) { + List addresses = senders(text(order, "network")); + require(!addresses.isEmpty(), "当前网络未配置提现付款地址,不能通过审核"); + changes.put("payout_sender_snapshot", encode(addresses)); + changes.put("approved_at", now()); + } else { + BigDecimal value = amount(order, "frozen_amount"); + funds.withdraw(number(order, "account_id"), id, "WITHDRAW_RELEASE", value, value.negate(), actor, "提现审核拒绝释放冻结"); + changes.put("active_user_id", null); + } + store.update("withdraw_order", id, changes); + store.event("WITHDRAW", id, approve ? "APPROVE" : "REJECT", actor, channel + ":" + reason.trim()); + log.info("提现审核完成 withdrawId={} approved={} actorId={} channel={} network={}", id, approve, actor, channel, order.get("network")); + return null; + }); + } + + /** Telegram数字ID必须显式映射到有效后台审核员,白名单由Telegram入口另行校验。 */ + public long telegramReviewer(String telegramId) { + String mappings = environment.getProperty("rental.withdraw.telegram-reviewers", ""); + for (String item : mappings.split(",")) { + String[] pair = item.trim().split(":"); + if (pair.length == 2 && pair[0].equals(telegramId) && pair[1].matches("[1-9][0-9]*")) { + long user = Long.parseLong(pair[1]); + Map allowed = store.one("SELECT u.user_id FROM sys_user u WHERE u.user_id=? AND u.status='0' AND u.del_flag='0'" + + " AND (u.user_id=1 OR EXISTS(SELECT 1 FROM sys_user_role ur JOIN sys_role r ON r.role_id=ur.role_id" + + " JOIN sys_role_menu rm ON rm.role_id=r.role_id JOIN sys_menu m ON m.menu_id=rm.menu_id" + + " WHERE ur.user_id=u.user_id AND r.status='0' AND r.del_flag='0' AND m.status='0' AND m.perms='rent:withdraw:review'))", user); + require(allowed != null, "Telegram映射用户没有提现审核权限"); + return user; + } + } + throw new IllegalArgumentException("未配置Telegram用户与提现审核员的映射"); + } + + /** 管理员登记交易与日志;未确认/不匹配只保存审计,资金继续冻结。链上调用在事务外。 */ + public Map manual(long id, Map request, long actor) { + String hash = input(request, "transaction_id", 64).toLowerCase(Locale.ROOT); + require(hash.matches("[0-9a-f]{64}"), "Hash必须为64位十六进制"); + String remark = input(request, "remark", 512); + Integer index = request.containsKey("log_index") && !text(request, "log_index").isEmpty() + ? Math.toIntExact(number(request, "log_index")) : null; + require(index == null || index >= 0, "日志索引不能为负"); + log.info("提现人工核验开始 withdrawId={} actorId={} hash={} logIndex={}", id, actor, hash, index); + Map order = transactions.execute(status -> { + Map current = store.get("withdraw_order", id, true); + require(EXECUTABLE.contains(text(current, "status")) || "COMPLETED".equals(text(current, "status")), "提现尚未审核通过"); + if (!"COMPLETED".equals(text(current, "status"))) { + store.event("WITHDRAW", id, "MANUAL_SUBMIT", actor, "Hash=" + hash + ";" + remark); + store.update("withdraw_order", id, map("status", "VERIFYING")); + } + return current; + }); + if ("COMPLETED".equals(text(order, "status"))) { + return detail(0, id, true); + } + try { + List> candidates = new ArrayList<>(); + for (Map event : chain.events(text(order, "network"), hash)) { + long eventId = record(event, "ADMIN_SUBMIT"); + if ((index == null || number(event, "log_index") == index) && matches(order, event)) { + candidates.add(store.get("withdraw_transaction", eventId, false)); + } + } + require(candidates.size() == 1, "没有唯一匹配的已确认提现交易,请核对网络、付款方、金额、时间及日志索引"); + complete(id, number(candidates.get(0), "id"), "MANUAL", actor, remark); + } catch (RuntimeException ex) { + failure(id, "人工核验尚未通过,资金继续冻结,请核对Hash及付款条件", ex); + } + return detail(0, id, true); + } + + /** 保存已确认的链上事件,重复扫描只更新时间,不覆盖原始证据或认领关系。 */ + public long record(Map event, String source) { + return Objects.requireNonNull(transactions.execute(status -> { + String evidence = encode(map("network", event.get("network"), "tx", event.get("transaction_id"), + "log_index", event.get("log_index"), "block", event.get("block_number"), "block_hash", event.get("block_hash"))); + store.execute("INSERT INTO rent_withdraw_transaction(network,transaction_id,log_index,token_contract,from_address,to_address,amount_units,amount_usdt," + + "block_number,block_hash,block_time,discovery_source,verify_status,match_status,evidence,last_checked_at,created_at,updated_at,version)" + + " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,'CONFIRMED','UNMATCHED',?,?,?,?,0) ON DUPLICATE KEY UPDATE last_checked_at=?", + event.get("network"), event.get("transaction_id"), event.get("log_index"), event.get("token_contract"), + event.get("from_address"), event.get("to_address"), event.get("amount_units"), event.get("amount_usdt"), + event.get("block_number"), event.get("block_hash"), event.get("block_time"), source, + evidence, now(), now(), now(), now()); + Map row = store.one("SELECT * FROM rent_withdraw_transaction WHERE network=? AND transaction_id=? AND log_index=? FOR UPDATE", + event.get("network"), event.get("transaction_id"), event.get("log_index")); + require(text(row, "from_address").equals(text(event, "from_address")) + && text(row, "to_address").equals(text(event, "to_address")) + && amount(row, "amount_usdt").compareTo(amount(event, "amount_usdt")) == 0 + && number(row, "block_number") == number(event, "block_number") + && text(row, "token_contract").equals(text(event, "token_contract")) + && time(row.get("block_time")).equals(time(event.get("block_time"))) + && text(row, "block_hash").equals(text(event, "block_hash")), "链上事件证据发生冲突,需人工核对"); + return number(row, "id"); + })); + } + + public void autoMatch(long eventId) { + Map event = store.get("withdraw_transaction", eventId, false); + if (event.get("withdraw_id") != null) { + return; + } + List> candidates = new ArrayList<>(); + for (Map order : store.rows("SELECT * FROM rent_withdraw_order WHERE network=? AND receiver_address=? AND amount=?" + + " AND status IN ('EXECUTING','VERIFYING','MANUAL_REVIEW') AND approved_at order = candidates.get(0); + int matchingEvents = 0; + for (Map payment : store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? AND to_address=?" + + " AND amount_usdt=? AND block_time>? AND withdraw_id IS NULL AND verify_status='CONFIRMED'", + order.get("network"), order.get("receiver_address"), order.get("amount"), order.get("approved_at"))) { + if (matches(order, payment)) { matchingEvents++; } + } + if (matchingEvents > 1) { + transactions.execute(status -> { + Map current = store.get("withdraw_order", number(order, "id"), true); + if (EXECUTABLE.contains(text(current, "status"))) { + store.update("withdraw_order", number(order, "id"), map("status", "MANUAL_REVIEW", + "last_error", "存在多笔相同付款,请管理员指定Hash及日志索引核验")); + } + return null; + }); + log.warn("提现发现多笔候选付款 withdrawId={} eventCount={},保持冻结等待人工核对", order.get("id"), matchingEvents); + return; + } + complete(number(candidates.get(0), "id"), eventId, "AUTO", 0, "链上监听自动匹配并确认到账"); + } else if (candidates.size() > 1) { + transactions.execute(status -> { + // 与完成路径统一先订单后事件,避免人工核验与歧义处理反向持锁。 + for (Map order : candidates) { + Map current = store.get("withdraw_order", number(order, "id"), true); + if (EXECUTABLE.contains(text(current, "status"))) { + store.update("withdraw_order", number(order, "id"), map("status", "MANUAL_REVIEW", "last_error", "交易匹配多个提现申请,请人工选择")); + } + } + store.update("withdraw_transaction", eventId, map("match_status", "AMBIGUOUS")); + return null; + }); + log.warn("提现自动匹配存在歧义 eventId={} candidateCount={},不自动扣款", eventId, candidates.size()); + } + } + + /** 到账唯一事务:先锁提现单,再锁交易事件,最后锁资金账户;唯一事件与唯一流水双重防重。 */ + public void complete(long id, long eventId, String mode, long actor, String remark) { + require(Arrays.asList("MANUAL", "AUTO").contains(mode), "到账方式无效"); + transactions.execute(status -> { + Map order = store.get("withdraw_order", id, true); + if ("COMPLETED".equals(text(order, "status"))) { + log.info("提现到账幂等命中 withdrawId={} originalMode={}", id, order.get("arrival_mode")); + return null; + } + require(EXECUTABLE.contains(text(order, "status")), "提现未进入执行状态"); + Map event = store.get("withdraw_transaction", eventId, true); + require("CONFIRMED".equals(text(event, "verify_status")) && event.get("withdraw_id") == null && matches(order, event), + "交易已被使用或不符合提现付款条件"); + BigDecimal value = amount(order, "frozen_amount"); + funds.withdraw(number(order, "account_id"), id, "WITHDRAW_COMPLETE", ZERO, value.negate(), actor, remark); + store.update("withdraw_transaction", eventId, map("withdraw_id", id, "match_status", "MATCHED")); + store.update("withdraw_order", id, map("status", "COMPLETED", "active_user_id", null, + "arrival_mode", mode, "arrival_transaction_id", eventId, "arrival_operator_id", actor == 0 ? null : actor, + "arrival_remark", remark, "completed_at", now(), "last_error", null, "last_check_at", now())); + store.event("WITHDRAW", id, "COMPLETE_" + mode, actor, "Hash=" + event.get("transaction_id") + ";" + remark); + log.info("提现到账成功 withdrawId={} network={} mode={} eventId={} hash={} logIndex={} amountUsdt={} actorId={}", + id, order.get("network"), mode, eventId, event.get("transaction_id"), event.get("log_index"), value, actor); + return null; + }); + } + + private boolean matches(Map order, Map event) { + return order.get("approved_at") != null && text(order, "network").equals(text(event, "network")) + && text(order, "receiver_address").equals(text(event, "to_address")) + && amount(order, "amount").compareTo(amount(event, "amount_usdt")) == 0 + && time(event.get("block_time")).isAfter(time(order.get("approved_at"))) + && snapshotSenders(order).contains(text(event, "from_address")); + } + + public List senders(String network) { + List result = new ArrayList<>(); + String configured = environment.getProperty("rental.withdraw." + network(network).toLowerCase(Locale.ROOT) + ".payout-addresses", ""); + for (String address : configured.split(",")) { + if (!address.trim().isEmpty()) { + RentalOrders.address(address.trim()); + result.add(address.trim()); + } + } + return result; + } + + public List snapshotSenders(Map order) { + try { + return json.readValue(text(order, "payout_sender_snapshot"), new TypeReference>() { }); + } catch (Exception ex) { + throw new IllegalArgumentException("提现付款地址快照无效,保留冻结等待人工核对"); + } + } + + public Map list(long user, String network, String status, int page, boolean manage) { + network(network); + require(page >= 1 && page <= 100000, "页码无效"); + String filter = " WHERE network=?" + (manage ? "" : " AND user_id=?") + (status.isEmpty() ? "" : " AND status=?"); + List args = new ArrayList<>(); + args.add(network); + if (!manage) { args.add(user); } + if (!status.isEmpty()) { args.add(status); } + List> rows = new ArrayList<>(); + for (Map row : store.rows("SELECT * FROM rent_withdraw_order" + filter + " ORDER BY id DESC LIMIT 20 OFFSET " + (page - 1) * 20, args.toArray())) { + rows.add(view(row)); + } + Map active = manage ? null : store.one("SELECT * FROM rent_withdraw_order WHERE active_user_id=?", user); + Map cursor = manage ? store.one("SELECT last_block,updated_at,last_error FROM rent_withdraw_scan_cursor WHERE network=?", network) : null; + if (cursor != null) { cursor.put("updated_at", time(cursor.get("updated_at")).toEpochMilli()); } + return map("rows", rows, "active", active == null ? null : view(active), "enabled", enabled(), + "scan_enabled", environment.getProperty("rental.withdraw.scan-enabled", Boolean.class, false), "scan", cursor, + "min_amount", environment.getProperty("rental.withdraw.min-amount-usdt", "1"), + "max_amount", environment.getProperty("rental.withdraw.max-amount-usdt", "10000")); + } + + public Map detail(long user, long id, boolean manage) { + Map order = store.get("withdraw_order", id, false); + require(manage || number(order, "user_id") == user, "无权查看此提现申请"); + Map result = view(order); + if (manage) { + // 待审核展示当前网络配置;通过后展示审核快照,避免配置轮换误导实际付款。 + result.put("payout_addresses", order.get("approved_at") == null + ? senders(text(order, "network")) : snapshotSenders(order)); + result.put("payout_addresses_snapshot", order.get("approved_at") != null); + } + List> events = store.rows("SELECT action,actor_user_id,reason,created_at FROM rent_event WHERE object_type='WITHDRAW' AND object_id=? ORDER BY id", id); + for (Map event : events) { event.put("created_at", time(event.get("created_at")).toEpochMilli()); } + result.put("events", events); + List> transfers = store.rows("SELECT * FROM rent_withdraw_transaction WHERE withdraw_id=?", id); + if (manage) { + transfers = store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? AND to_address=? AND block_time>? ORDER BY id DESC LIMIT 50", + order.get("network"), order.get("receiver_address"), order.get("approved_at") == null ? order.get("created_at") : order.get("approved_at")); + } + for (Map transfer : transfers) { + if (manage) { transfer.put("match_reason", matchReason(order, transfer)); } + for (String key : Arrays.asList("created_at", "updated_at", "last_checked_at", "block_time")) { + transfer.put(key, time(transfer.get(key)).toEpochMilli()); + } + } + result.put("transactions", transfers); + return result; + } + + /** 运营只读交易列表,方便定位未匹配/重复付款;不提供直接修改认领或删除证据的接口。 */ + public List> transactions(String network, String hash, int page) { + network(network); + require(page >= 1 && page <= 100000 && (hash.isEmpty() || hash.matches("[0-9a-fA-F]{64}")), "页码或交易Hash无效"); + List> rows = hash.isEmpty() + ? store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? ORDER BY id DESC LIMIT 20 OFFSET " + (page - 1) * 20, network) + : store.rows("SELECT * FROM rent_withdraw_transaction WHERE network=? AND transaction_id=? ORDER BY id DESC LIMIT 20 OFFSET " + (page - 1) * 20, network, hash.toLowerCase(Locale.ROOT)); + for (Map row : rows) { + for (String key : Arrays.asList("created_at", "updated_at", "block_time", "last_checked_at")) { + row.put(key, time(row.get(key)).toEpochMilli()); + } + } + return rows; + } + + private String matchReason(Map order, Map event) { + if (order.get("approved_at") == null) { return "尚未审核通过"; } + if (event.get("withdraw_id") != null) { return "已由提现单#" + event.get("withdraw_id") + "核销"; } + if (!snapshotSenders(order).contains(text(event, "from_address"))) { return "付款地址不在审核快照内"; } + if (amount(order, "amount").compareTo(amount(event, "amount_usdt")) != 0) { return "金额不一致,不合并拆分付款"; } + if (!time(event.get("block_time")).isAfter(time(order.get("approved_at")))) { return "交易时间不晚于审核时间"; } + return "AMBIGUOUS".equals(text(event, "match_status")) ? "匹配多个申请,需人工选择" : "符合当前申请付款条件"; + } + + private Map view(Map order) { + Map result = new LinkedHashMap<>(order); + result.remove("request_hash"); + for (String key : Arrays.asList("created_at", "updated_at", "approved_at", "reviewed_at", "completed_at", "last_check_at")) { + result.put(key, order.get(key) == null ? null : time(order.get(key)).toEpochMilli()); + } + return result; + } + + private void failure(long id, String hint, RuntimeException ex) { + store.execute("UPDATE rent_withdraw_order SET last_error=?,last_check_at=?,updated_at=? WHERE id=? AND status<>'COMPLETED'", hint, now(), now(), id); + log.warn("提现核验未完成 withdrawId={} diagnostic={};保留冻结", id, RentalDiagnostics.describe(ex)); + } + + private void createTelegramAudit(Map order) { + if (!environment.getProperty("telegram.enabled", Boolean.class, false)) { return; } + TelegramAuditRecord record = new TelegramAuditRecord(); + record.setAuditNo("RW-" + order.get("id") + "-" + java.util.UUID.randomUUID().toString().substring(0, 8)); + record.setBusinessType(TELEGRAM_TYPE); + record.setBusinessId(text(order, "id")); + record.setTitle("租赁资金账户提现审核"); + record.setAuditStatus("PENDING"); + record.setPayload(encode(map("withdrawNo", order.get("withdraw_no"), "userId", order.get("user_id"), + "network", order.get("network"), "amount", order.get("amount"), "address", order.get("receiver_address")))); + Date date = new Date(); + record.setCreatedAt(date); + record.setUpdatedAt(date); + telegram.insertRecord(record); + telegram.insertPushTask(record.getAuditNo(), date, date); + } + + private String optional(Map request, String key) { + String value = text(request, key).trim(); + require(value.length() <= 512 && !value.contains("\r") && !value.contains("\n"), "备注最多512字且不能换行"); + return value; + } + + private String encode(Object value) { + try { return json.writeValueAsString(value); } + catch (Exception ex) { throw new IllegalArgumentException("提现数据序列化失败"); } + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/service/TelegramAuditService.java b/ruoyi-system/src/main/java/com/ruoyi/system/service/TelegramAuditService.java index f74e32f..7f7d051 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/service/TelegramAuditService.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/service/TelegramAuditService.java @@ -37,6 +37,8 @@ public class TelegramAuditService { private static final Logger LOGGER = LoggerFactory.getLogger(TelegramAuditService.class); private static final String BUSINESS_TYPE = "USDT_AGGREGATION"; private static final String PAYOUT_BUSINESS_TYPE = "USDT_PAYOUT"; + @org.springframework.beans.factory.annotation.Autowired + private com.ruoyi.system.rental.RentalWithdrawals rentalWithdrawals; private static final int MAX_PUSH_RETRIES = 8; private final TelegramAuditMapper mapper; @@ -289,7 +291,11 @@ public class TelegramAuditService { boolean approved = "A".equals(parts[2]); String newStatus = approved ? "APPROVED" : "REJECTED"; - if (PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())) { + if (com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE.equals(record.getBusinessType())) { + long reviewer = rentalWithdrawals.telegramReviewer(userId); + rentalWithdrawals.review(Long.parseLong(record.getBusinessId()), approved, reviewer, + "TELEGRAM", userId, "Telegram审核,数字用户ID=" + userId); + } else if (PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType())) { payoutOrderService.review(Long.valueOf(record.getBusinessId()), approved, "TELEGRAM", userId, "Telegram审核"); } else { @@ -357,6 +363,26 @@ public class TelegramAuditService { return parts; } + /** 后台与Telegram共用业务状态和审核记录,任一入口处理后另一入口不能覆盖决定。 */ + @Transactional(rollbackFor = Exception.class) + public void reviewRentalWithdrawFromBackoffice(long id, boolean approved, String reason) { + rentalWithdrawals.review(id, approved, SecurityUtils.getUserId(), "BACKOFFICE", null, reason); + if (!enabled) { return; } + TelegramAuditRecord record = mapper.selectByBusiness( + com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE, String.valueOf(id)); + if (record == null || !"PENDING".equals(record.getAuditStatus())) { return; } + String status = approved ? "APPROVED" : "REJECTED"; + Date now = new Date(); + if (mapper.approve(record.getAuditNo(), status, "SYSTEM", SecurityUtils.getUsername(), now, now) != 1) { + throw new CustomException("提现审核已被其他入口处理,请刷新"); + } + record.setAuditStatus(status); + record.setReviewerName(SecurityUtils.getUsername()); + record.setReviewerTelegramId("SYSTEM"); + record.setReviewedAt(now); + afterCommit(null, record, approved ? "提现审核通过,等待付款" : "提现审核拒绝,资金已释放"); + } + private void afterCommit(final String callbackId, final TelegramAuditRecord record, final String answerText) { TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() { @@ -405,7 +431,12 @@ public class TelegramAuditService { private Long sendAuditMessage(TelegramAuditRecord record) { JSONObject payload = JSONObject.parseObject(record.getPayload()); - String text = PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType()) + String text = com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE.equals(record.getBusinessType()) + ? "租赁提现审核\n审核单:" + record.getAuditNo() + "\n提现单:" + payload.getString("withdrawNo") + + "\n用户:" + payload.getString("userId") + "\n网络:" + payload.getString("network") + + "\n金额:" + payload.getString("amount") + " USDT\n收款地址:" + payload.getString("address") + + "\n通过后仅进入执行状态,不自动转账。" + : PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType()) ? "代付审核\n审核单:" + record.getAuditNo() + "\n商户订单:" + payload.getString("orderId") + "\n金额:" + payload.getString("amount") + " " + payload.getString("currency") + "\n手续费:" + payload.getString("fee") + " TRX\n收款地址:" + payload.getString("address") @@ -444,7 +475,11 @@ public class TelegramAuditService { Map body = new HashMap<>(); body.put("chat_id", record.getTelegramChatId()); body.put("message_id", record.getTelegramMessageId()); - String text = PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType()) + String text = com.ruoyi.system.rental.RentalWithdrawals.TELEGRAM_TYPE.equals(record.getBusinessType()) + ? "租赁提现审核 - " + result + "\n提现单:" + payload.getString("withdrawNo") + + "\n网络:" + payload.getString("network") + "\n金额:" + payload.getString("amount") + + " USDT\n收款地址:" + payload.getString("address") + "\n审核人:" + reviewer + : PAYOUT_BUSINESS_TYPE.equals(record.getBusinessType()) ? "代付审核 - " + result + "\n审核单:" + record.getAuditNo() + "\n商户订单:" + payload.getString("orderId") + "\n金额:" + payload.getString("amount") + " " + payload.getString("currency") diff --git a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawChainTest.java b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawChainTest.java new file mode 100644 index 0000000..8e9a350 --- /dev/null +++ b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawChainTest.java @@ -0,0 +1,75 @@ +package com.ruoyi.system.rental; + +import static com.ruoyi.system.rental.RentalValues.*; +import static org.junit.Assert.*; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import org.junit.Test; +import org.tron.trident.core.ApiWrapper; + +/** 真实解码器配合可控RPC回执,验证代币、最小单位和确认边界,不访问公网。 */ +public class RentalWithdrawChainTest { + private static final String TOKEN = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb"; + private static final String RECEIVER = "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf"; + private static final String HASH = String.join("", Collections.nCopies(64, "a")); + private static final String TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"; + private final ObjectMapper json = new ObjectMapper(); + private long head = 10; + private String token = TOKEN; + private String result = "SUCCESS"; + private long receiptTime = 1700000000000L; + + private RentalWithdrawChain chain() { + RentalChain rpc = new RentalChain(json) { + @Override public JsonNode call(String network, String path, Map body) { + if (path.endsWith("gettransactioninfobyid")) { + return json.valueToTree(map("id", HASH, "blockNumber", 10, "blockTimeStamp", receiptTime, + "receipt", map("result", result), "log", Collections.singletonList(map( + "address", hex(token).substring(2), "topics", java.util.Arrays.asList(TOPIC, topic(TOKEN), topic(RECEIVER)), + "data", String.format("%064x", 30000000))))); + } + if (path.endsWith("gettransactionbyid")) { + return json.valueToTree(map("txID", HASH, "ret", Collections.singletonList(map("contractRet", result)))); + } + if (path.endsWith("getblockbynum")) { + return json.valueToTree(map("blockID", HASH, "block_header", map("raw_data", map("number", 10, "timestamp", 1700000000000L)))); + } + throw new AssertionError("未知RPC路径 " + path); + } + }; + return new RentalWithdrawChain(rpc, null) { + @Override public String contract(String network) { return TOKEN; } + @Override public long confirmedHead(String network) { return head; } + }; + } + + @Test public void decodesExactUsdtUnitsAndBase58Addresses() { + List> events = chain().events("NILE", HASH); + assertEquals(1, events.size()); + assertEquals(money("30"), amount(events.get(0), "amount_usdt")); + assertEquals(RECEIVER, text(events.get(0), "to_address")); + assertEquals(TOKEN, text(events.get(0), "from_address")); + assertEquals(0, number(events.get(0), "log_index")); + } + + @Test public void ignoresOtherTokenAndFailedReceipt() { + token = RECEIVER; + assertTrue(chain().events("NILE", HASH).isEmpty()); + token = TOKEN; result = "REVERT"; + assertTrue(chain().events("NILE", HASH).isEmpty()); + } + + @Test public void rejectsUnconfirmedAndInconsistentBlockEvidence() { + head = 9; + try { chain().events("NILE", HASH); fail("未确认不能到账"); } catch (IllegalArgumentException expected) { /* 保持冻结 */ } + head = 10; receiptTime++; + try { chain().events("NILE", HASH); fail("时间冲突不能到账"); } catch (IllegalArgumentException expected) { /* 保持冻结 */ } + } + + private static String hex(String address) { return ApiWrapper.toHex(ApiWrapper.parseAddress(address)); } + private static String topic(String address) { return "000000000000000000000000" + hex(address).substring(2); } +} diff --git a/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawTest.java b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawTest.java new file mode 100644 index 0000000..e5925dc --- /dev/null +++ b/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalWithdrawTest.java @@ -0,0 +1,290 @@ +package com.ruoyi.system.rental; + +import static com.ruoyi.system.rental.RentalValues.*; +import static org.junit.Assert.*; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.ruoyi.system.mapper.TelegramAuditMapper; +import java.lang.reflect.Proxy; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import org.h2.jdbcx.JdbcDataSource; +import org.junit.Before; +import org.junit.Test; +import org.springframework.core.env.MapPropertySource; +import org.springframework.core.env.StandardEnvironment; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.DataSourceTransactionManager; +import org.springframework.transaction.support.TransactionTemplate; + +/** 真实H2事务、并发锁及持久游标;RPC/Telegram均隔离,不访问真实钱包或发送消息。 */ +public class RentalWithdrawTest { + private static final String SENDER = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb"; + private static final String RECEIVER = "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf"; + private static final String HASH = String.join("", Collections.nCopies(64, "a")); + private final ObjectMapper json = new ObjectMapper(); + private RentalStore store; + private RentalFunds funds; + private RentalWithdrawals service; + private FakeChain chain; + private StandardEnvironment environment; + private Map config; + private TransactionTemplate tx; + private long account; + private int telegramRecords; + private int telegramPushes; + + @Before + public void setup() throws Exception { + JdbcDataSource source = new JdbcDataSource(); + source.setURL("jdbc:h2:mem:" + UUID.randomUUID() + ";MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000"); + JdbcTemplate jdbc = new JdbcTemplate(source); + store = new RentalStore(jdbc); + String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_init.sql")), StandardCharsets.UTF_8) + .replaceAll("(?m)^--.*$", "").replace("CHARACTER SET ascii COLLATE ascii_bin", "") + .replaceAll("(?i)\\bJSON\\b", "LONGTEXT") + .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); + for (String sql : ddl.split(";")) { if (!sql.trim().isEmpty()) { jdbc.execute(sql); } } + DataSourceTransactionManager manager = new DataSourceTransactionManager(source); + tx = new TransactionTemplate(manager); + funds = new RentalFunds(store); + account = number(funds.account(10, "NILE"), "id"); + long mainnet = number(funds.account(10, "MAINNET"), "id"); + tx.execute(status -> { + for (long id : new long[] {account, mainnet}) { + funds.post(id, "INITIAL:" + id, "TOPUP", money("100"), ZERO, ZERO, ZERO, null, null, null, 0, null, "fixture"); + } + return null; + }); + config = map("rental.enabled", "true", "rental.withdraw.enabled", "true", + "rental.withdraw.nile.payout-addresses", SENDER, "rental.withdraw.mainnet.payout-addresses", SENDER); + environment = new StandardEnvironment(); + environment.getPropertySources().addFirst(new MapPropertySource("test", config)); + chain = new FakeChain(); + TelegramAuditMapper telegram = (TelegramAuditMapper) Proxy.newProxyInstance(getClass().getClassLoader(), + new Class[] {TelegramAuditMapper.class}, (proxy, method, args) -> { + if ("insertRecord".equals(method.getName())) { telegramRecords++; return 1; } + if ("insertPushTask".equals(method.getName())) { telegramPushes++; return 1; } + return null; + }); + service = new RentalWithdrawals(store, funds, chain, environment, json, telegram, manager); + } + + @Test + public void freezesOnceAndBlocksAnotherNetworkUntilRejection() { + Map order = create("first"); + long id = number(order, "id"); + assertEquals(id, number(create("first"), "id")); + assertEquals(money("70"), amount(store.get("account", account, false), "available_amount")); + assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount")); + rejected(() -> service.create(10, request("other", "MAINNET"))); + Map conflict = request("first", "NILE"); conflict.put("amount", "31"); + rejected(() -> service.create(10, conflict)); + rejected(() -> service.review(id, true, 10, "BACKOFFICE", null, "self")); + service.review(id, false, 99, "BACKOFFICE", null, "拒绝测试"); + assertEquals(money("100"), amount(store.get("account", account, false), "available_amount")); + assertEquals(ZERO, amount(store.get("account", account, false), "frozen_amount")); + rejected(() -> service.review(id, true, 99, "BACKOFFICE", null, "重复审核")); + assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_RELEASE'").size()); + assertNotNull(service.create(10, request("after-rejection", "MAINNET"))); + assertEquals("MAINNET", text((Map) service.list(10, "NILE", "", 1, false).get("active"), "network")); + rejected(() -> service.detail(20, id, false)); + } + + @Test + public void manualAndAutoCompletionCompeteWithoutDoubleCharging() throws Exception { + Map order = approved("race"); + long id = number(order, "id"); + Map event = event(order, HASH, 0); + long eventId = service.record(event, "SCAN"); + ExecutorService executor = Executors.newFixedThreadPool(2); + CountDownLatch start = new CountDownLatch(1); + try { + Future manual = executor.submit(() -> { await(start); service.complete(id, eventId, "MANUAL", 99, "人工确认"); }); + Future auto = executor.submit(() -> { await(start); service.autoMatch(eventId); }); + start.countDown(); manual.get(); auto.get(); + } finally { executor.shutdownNow(); } + service.autoMatch(eventId); + assertEquals("COMPLETED", text(store.get("withdraw_order", id, false), "status")); + assertEquals(ZERO, amount(store.get("account", account, false), "frozen_amount")); + assertEquals(money("70"), amount(store.get("account", account, false), "available_amount")); + assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_COMPLETE'").size()); + assertTrue(Arrays.asList("MANUAL", "AUTO").contains(text(store.get("withdraw_order", id, false), "arrival_mode"))); + assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE withdraw_id=? AND event_type='WITHDRAW_COMPLETE'", id).size()); + } + + @Test + public void manualUnknownKeepsFrozenThenSameHashCanComplete() { + Map order = approved("manual"); + long id = number(order, "id"); + chain.fail = true; + Map request = map("transaction_id", HASH, "remark", "管理员已经在钱包付款"); + assertEquals("VERIFYING", text(service.manual(id, request, 99), "status")); + assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount")); + chain.fail = false; + chain.events = Collections.singletonList(event(order, HASH, 0)); + assertEquals("MANUAL", text(service.manual(id, request, 99), "arrival_mode")); + assertEquals("COMPLETED", text(service.manual(id, request, 99), "status")); + assertEquals(1, store.rows("SELECT id FROM rent_withdraw_transaction").size()); + } + + @Test + public void autoMatchingRejectsWrongTimeSenderAmountNetworkAndAmbiguousApplicants() { + Map order = approved("matching"); + List> wrong = new ArrayList<>(); + Map early = event(order, HASH, 0); early.put("block_time", order.get("approved_at")); wrong.add(early); + Map sender = event(order, HASH, 1); sender.put("from_address", RECEIVER); wrong.add(sender); + Map amount = event(order, HASH, 2); amount.put("amount_usdt", money("29")); wrong.add(amount); + Map network = event(order, HASH, 3); network.put("network", "MAINNET"); wrong.add(network); + for (Map event : wrong) { service.autoMatch(service.record(event, "SCAN")); } + assertEquals("EXECUTING", text(store.get("withdraw_order", number(order, "id"), false), "status")); + assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount")); + long another = number(funds.account(20, "NILE"), "id"); + tx.execute(status -> { funds.post(another, "INITIAL20", "TOPUP", money("100"), ZERO, ZERO, ZERO, null, null, null, 0, null, "fixture"); return null; }); + long other = number(service.create(20, request("same-address", "NILE")), "id"); + service.review(other, true, 99, "TELEGRAM", "123", "通过"); + Map valid = event(order, HASH, 4); valid.put("block_time", now().plusSeconds(2)); + long eventId = service.record(valid, "SCAN"); + service.autoMatch(eventId); + assertEquals("AMBIGUOUS", text(store.get("withdraw_transaction", eventId, false), "match_status")); + assertEquals("MANUAL_REVIEW", text(store.get("withdraw_order", other, false), "status")); + service.complete(number(order, "id"), eventId, "MANUAL", 99, "核对实际付款记录确认来源"); + rejected(() -> service.complete(other, eventId, "MANUAL", 99, "重复核销")); + } + + @Test + public void twoConcurrentApplicationsHaveOnlyOneActiveAndOneHold() throws Exception { + ExecutorService executor = Executors.newFixedThreadPool(2); + CountDownLatch start = new CountDownLatch(1); + try { + List> results = new ArrayList<>(); + for (String network : new String[] {"NILE", "MAINNET"}) { + results.add(executor.submit(() -> { await(start); try { service.create(10, request("parallel-" + network, network)); return true; } catch (IllegalArgumentException ex) { return false; } })); + } + start.countDown(); + int success = 0; for (Future result : results) { if (result.get()) { success++; } } + assertEquals(1, success); + assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_HOLD'").size()); + assertEquals(1, store.rows("SELECT id FROM rent_withdraw_order WHERE active_user_id=10").size()); + } finally { executor.shutdownNow(); } + } + + @Test + public void telegramQueuePersistsOnceAndInvalidConfigurationCannotFreeze() { + config.put("telegram.enabled", "true"); + create("telegram"); create("telegram"); + assertEquals(1, telegramRecords); assertEquals(1, telegramPushes); + config.put("rental.withdraw.enabled", "false"); + assertNotNull(create("telegram")); + rejected(() -> service.create(20, request("disabled", "NILE"))); + assertEquals(1, store.rows("SELECT id FROM rent_withdraw_order").size()); + } + + @Test + public void scannerResumesAfterRpcFailureAndCompletesAutomatically() { + Map order = approved("scanner"); + chain.events = Collections.singletonList(event(order, HASH, 0)); + RentalWithdrawScanner scanner = new RentalWithdrawScanner(store, service, chain, environment); + chain.fail = true; + try { scanner.scan("NILE"); fail("RPC失败不能推进游标"); } catch (IllegalStateException expected) { /* 可恢复 */ } + assertEquals("EXECUTING", text(store.get("withdraw_order", number(order, "id"), false), "status")); + chain.fail = false; + scanner.scan("NILE"); + assertEquals("COMPLETED", text(store.get("withdraw_order", number(order, "id"), false), "status")); + assertEquals("AUTO", text(store.get("withdraw_order", number(order, "id"), false), "arrival_mode")); + assertEquals(1, store.rows("SELECT id FROM rent_withdraw_transaction").size()); + scanner.scan("NILE"); + assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_COMPLETE'").size()); + } + + @Test + public void duplicatePaymentsRequireManualSelectionWithoutUnfreezing() { + Map order = approved("duplicate-payments"); + long first = service.record(event(order, HASH, 0), "SCAN"); + service.record(event(order, HASH, 1), "SCAN"); + service.autoMatch(first); + assertEquals("MANUAL_REVIEW", text(store.get("withdraw_order", number(order, "id"), false), "status")); + assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount")); + assertTrue(store.rows("SELECT id FROM rent_ledger WHERE event_type='WITHDRAW_COMPLETE'").isEmpty()); + service.complete(number(order, "id"), first, "MANUAL", 99, "人工核对两笔付款后选择第一笔"); + assertEquals(ZERO, amount(store.get("account", account, false), "frozen_amount")); + } + + @Test + public void telegramApprovalUsesMappedReviewerAndRejectsDuplicateCallback() throws Exception { + store.execute("CREATE TABLE sys_user(user_id BIGINT,status VARCHAR(1),del_flag VARCHAR(1))"); + store.execute("CREATE TABLE sys_user_role(user_id BIGINT,role_id BIGINT)"); + store.execute("CREATE TABLE sys_role(role_id BIGINT,status VARCHAR(1),del_flag VARCHAR(1))"); + store.execute("CREATE TABLE sys_role_menu(role_id BIGINT,menu_id BIGINT)"); + store.execute("CREATE TABLE sys_menu(menu_id BIGINT,status VARCHAR(1),perms VARCHAR(100))"); + store.execute("INSERT INTO sys_user VALUES(1,'0','0')"); + config.put("rental.withdraw.telegram-reviewers", "123:1"); + assertEquals(1, service.telegramReviewer("123")); + rejected(() -> service.telegramReviewer("456")); + Map order = create("telegram-routing"); + com.ruoyi.system.domain.TelegramAuditRecord audit = new com.ruoyi.system.domain.TelegramAuditRecord(); + audit.setAuditNo("test-audit"); audit.setBusinessType(RentalWithdrawals.TELEGRAM_TYPE); + audit.setBusinessId(String.valueOf(number(order, "id"))); audit.setAuditStatus("PENDING"); + java.util.Set received = new java.util.HashSet<>(); + TelegramAuditMapper mapper = (TelegramAuditMapper) Proxy.newProxyInstance(getClass().getClassLoader(), + new Class[] {TelegramAuditMapper.class}, (proxy, method, args) -> { + if ("insertLog".equals(method.getName())) { return received.add((Long) args[1]) ? 1 : 0; } + if ("selectByAuditNo".equals(method.getName())) { return audit; } + if ("approve".equals(method.getName()) || "updateLogOutcome".equals(method.getName())) { return 1; } + return null; + }); + com.ruoyi.system.service.TelegramAuditService telegram = new com.ruoyi.system.service.TelegramAuditService( + mapper, null, null, tx.getTransactionManager()); + for (Map.Entry field : map("rentalWithdrawals", service, "allowedUserIds", "123", "botToken", "").entrySet()) { + java.lang.reflect.Field declared = telegram.getClass().getDeclaredField(field.getKey()); + declared.setAccessible(true); declared.set(telegram, field.getValue()); + } + com.alibaba.fastjson.JSONObject update = com.alibaba.fastjson.JSON.parseObject("{\"update_id\":1,\"callback_query\":{\"id\":\"callback\",\"from\":{\"id\":123},\"data\":\"ta:test-audit:A\"}}"); + tx.execute(status -> { telegram.handleUpdate(update); return null; }); + tx.execute(status -> { telegram.handleUpdate(update); return null; }); + Map reviewed = store.get("withdraw_order", number(order, "id"), false); + assertEquals("EXECUTING", text(reviewed, "status")); + assertEquals("TELEGRAM", text(reviewed, "review_channel")); + assertEquals(1, number(reviewed, "reviewer_user_id")); + assertEquals(money("30"), amount(store.get("account", account, false), "frozen_amount")); + } + + private Map create(String requestNo) { return service.create(10, request(requestNo, "NILE")); } + private Map request(String no, String network) { return map("network", network, "receiver_address", RECEIVER, "amount", "30", "client_request_no", no); } + private Map approved(String requestNo) { + long id = number(create(requestNo), "id"); + service.review(id, true, 99, "BACKOFFICE", null, "审核通过"); + return store.get("withdraw_order", id, false); + } + private Map event(Map order, String hash, int index) { + return map("network", "NILE", "transaction_id", hash, "log_index", index, "token_contract", SENDER, + "from_address", SENDER, "to_address", RECEIVER, "amount_units", 30000000, "amount_usdt", money("30"), + "block_number", 10, "block_hash", HASH, "block_time", LocalDateTime.ofInstant(time(order.get("approved_at")).plusSeconds(1), java.time.ZoneOffset.UTC)); + } + private static void await(CountDownLatch latch) { try { latch.await(); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); throw new IllegalStateException(ex); } } + private static void rejected(Runnable action) { try { action.run(); fail("必须拒绝"); } catch (IllegalArgumentException expected) { /* 预期校验 */ } } + + private final class FakeChain extends RentalWithdrawChain { + boolean fail; + List> events = Collections.emptyList(); + FakeChain() { super(null, null); } + @Override public long confirmedHead(String network) { if (fail) { throw new IllegalStateException("controlled RPC failure"); } return 10; } + @Override public JsonNode block(String network, long height) { return json.valueToTree(map("block_header", map("raw_data", map("number", height, "timestamp", System.currentTimeMillis() - (10 - height) * 3000 - 5000)))); } + @Override public JsonNode receipts(String network, long height) { return json.valueToTree(Collections.singletonList(map("id", HASH, "log", Collections.singletonList(map("fixture", true))))); } + @Override public boolean relevantLog(String network, JsonNode log, java.util.Set senders) { return true; } + @Override public List> events(String network, String hash) { if (fail) { throw new IllegalStateException("controlled unconfirmed"); } return events; } + } +} diff --git a/sql/rent_init.sql b/sql/rent_init.sql index 0d7455d..d1d3a65 100644 --- a/sql/rent_init.sql +++ b/sql/rent_init.sql @@ -366,6 +366,7 @@ CREATE TABLE IF NOT EXISTS `rent_ledger` ( `order_id` BIGINT NULL COMMENT '关联rent_order.id', `settlement_id` BIGINT NULL COMMENT '关联rent_settlement.id', `refund_id` BIGINT NULL COMMENT '退款或相关冲正关联rent_refund.id,每个退款内各事件使用独立business_key', + `withdraw_id` BIGINT NULL COMMENT '关联租赁提现单;冻结、释放、完成各自唯一流水', `reversal_of_id` BIGINT NULL COMMENT '冲正的rent_ledger.id', `operator_user_id` BIGINT NOT NULL COMMENT '操作者sys_user.user_id,后台系统为0', `evidence_ref` VARCHAR(255) NULL COMMENT '人工充值、付款或补偿审核依据编号;充值凭据必须全局防重复', @@ -490,3 +491,85 @@ CREATE TABLE IF NOT EXISTS `rent_event` ( UNIQUE KEY `uk_event_no` (`event_no`), KEY `idx_event_object` (`object_type`,`object_id`,`id`) ) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='业务操作和状态变更追加审计;关键事务同写'; + +-- 租赁提现新增表。重复执行不覆盖历史数据;先部署这些表,再开启提现配置。 +CREATE TABLE IF NOT EXISTS rent_withdraw_order ( + id BIGINT NOT NULL AUTO_INCREMENT, + withdraw_no VARCHAR(40) NOT NULL COMMENT '系统提现编号', + user_id BIGINT NOT NULL, + account_id BIGINT NOT NULL, + network VARCHAR(16) NOT NULL, + client_request_no VARCHAR(64) NOT NULL, + request_hash VARCHAR(64) NOT NULL, + receiver_address VARCHAR(64) NOT NULL, + amount DECIMAL(30,6) NOT NULL, + frozen_amount DECIMAL(30,6) NOT NULL, + status VARCHAR(24) NOT NULL COMMENT 'PENDING_REVIEW、EXECUTING、VERIFYING、MANUAL_REVIEW、REJECTED、COMPLETED', + active_user_id BIGINT NULL COMMENT '全网络同用户仅允许一笔在途,终结置NULL', + payout_sender_snapshot TEXT NULL COMMENT '审核时允许付款地址JSON快照,不含私钥', + review_channel VARCHAR(16) NULL, + reviewer_user_id BIGINT NULL, + reviewer_telegram_id VARCHAR(64) NULL, + review_reason VARCHAR(512) NULL, + approved_at DATETIME(3) NULL, + reviewed_at DATETIME(3) NULL, + arrival_mode VARCHAR(16) NULL COMMENT 'MANUAL或AUTO,最终完成时锁定', + arrival_transaction_id BIGINT NULL, + arrival_operator_id BIGINT NULL, + arrival_remark VARCHAR(512) NULL, + completed_at DATETIME(3) NULL, + remark VARCHAR(512) NOT NULL DEFAULT '', + last_check_at DATETIME(3) NULL, + last_error VARCHAR(512) NULL COMMENT '固定脱敏提示,不保存异常原文', + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_no(withdraw_no), + UNIQUE KEY uk_withdraw_request(user_id,client_request_no), + UNIQUE KEY uk_withdraw_active_user(active_user_id), + KEY idx_withdraw_user(user_id,network,id), + KEY idx_withdraw_pending(status,network,id) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='租赁可用余额提现审核单'; + +CREATE TABLE IF NOT EXISTS rent_withdraw_transaction ( + id BIGINT NOT NULL AUTO_INCREMENT, + network VARCHAR(16) NOT NULL, + transaction_id VARCHAR(64) NOT NULL, + log_index INT NOT NULL, + token_contract VARCHAR(64) NOT NULL, + from_address VARCHAR(64) NOT NULL, + to_address VARCHAR(64) NOT NULL, + amount_units DECIMAL(65,0) NOT NULL, + amount_usdt DECIMAL(65,6) NOT NULL, + block_number BIGINT NOT NULL, + block_hash VARCHAR(64) NULL, + block_time DATETIME(3) NOT NULL, + discovery_source VARCHAR(24) NOT NULL, + verify_status VARCHAR(24) NOT NULL, + match_status VARCHAR(24) NOT NULL, + withdraw_id BIGINT NULL COMMENT '唯一认领的提现单', + evidence TEXT NOT NULL COMMENT '筛选后的证据摘要,不存完整交易或认证数据', + last_checked_at DATETIME(3) NOT NULL, + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_chain_event(network,transaction_id,log_index), + UNIQUE KEY uk_withdraw_claim(withdraw_id), + KEY idx_withdraw_tx_match(network,to_address,match_status,block_time) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='手动提交及自动监听的已确认USDT事件'; + +CREATE TABLE IF NOT EXISTS rent_withdraw_scan_cursor ( + id BIGINT NOT NULL AUTO_INCREMENT, + network VARCHAR(16) NOT NULL, + last_block BIGINT NOT NULL, + lock_owner VARCHAR(64) NULL, + lock_until DATETIME(3) NULL, + last_error VARCHAR(512) NULL, + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_scan_network(network) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='提现自动扫描断点及多实例租约'; diff --git a/sql/rent_withdraw_menu.sql b/sql/rent_withdraw_menu.sql new file mode 100644 index 0000000..31bf105 --- /dev/null +++ b/sql/rent_withdraw_menu.sql @@ -0,0 +1,28 @@ +-- 先执行rent_menu.sql及rent_withdraw_migration.sql;不自动授予业务角色管理/审核权限。 +START TRANSACTION; +-- 当前初始化脚本使用rental;兼容已安装系统的proxyRent目录,优先复用现有工作台父目录。 +SET @withdraw_parent=COALESCE( + (SELECT parent_id FROM sys_menu WHERE perms='rent:portal:view' AND parent_id<>0 ORDER BY menu_id LIMIT 1), + (SELECT menu_id FROM sys_menu WHERE parent_id=0 AND path IN ('rental','proxyRent') ORDER BY menu_id LIMIT 1)); +INSERT INTO sys_menu(menu_name,parent_id,order_num,path,component,is_frame,is_cache,menu_type,visible,status,perms,icon,create_by,create_time) +SELECT '租赁提现审核',@withdraw_parent,30,'withdraw','rental/withdrawManage',1,0,'C','0','0','rent:withdraw:list','money','admin',NOW() +WHERE @withdraw_parent IS NOT NULL AND NOT EXISTS(SELECT 1 FROM sys_menu WHERE perms='rent:withdraw:list'); +SET @withdraw_menu=(SELECT menu_id FROM sys_menu WHERE perms='rent:withdraw:list' LIMIT 1); +INSERT INTO sys_menu(menu_name,parent_id,order_num,path,is_frame,is_cache,menu_type,visible,status,perms,icon,create_by,create_time) +SELECT p.label,COALESCE(@withdraw_menu,@withdraw_parent),99,'#',1,0,'F','0','0',p.perm,'#','admin',NOW() +FROM (SELECT '申请本人提现' label,'rent:withdraw:create' perm + UNION ALL SELECT '审核租赁提现','rent:withdraw:review' + UNION ALL SELECT '手动核验提现到账','rent:withdraw:execute') p +WHERE @withdraw_parent IS NOT NULL AND NOT EXISTS(SELECT 1 FROM sys_menu WHERE perms=p.perm); +-- 本人申请权限挂在资金账户菜单下,避免普通用户因按钮父菜单获得管理员入口。 +SET @withdraw_account=(SELECT menu_id FROM sys_menu WHERE component IN ('system/rentAccount/user/index','system/rentAccount/index') ORDER BY menu_id LIMIT 1); +UPDATE sys_menu SET parent_id=COALESCE(@withdraw_account,@withdraw_parent) WHERE perms='rent:withdraw:create'; +INSERT INTO sys_role_menu(role_id,menu_id) +SELECT r.role_id,m.menu_id FROM sys_role r JOIN sys_menu m ON m.perms='rent:withdraw:create' +WHERE r.role_key IN ('PROXY_ACCOUNT','PROXY_SUPPLIER') + AND NOT EXISTS(SELECT 1 FROM sys_role_menu x WHERE x.role_id=r.role_id AND x.menu_id=m.menu_id); +-- 超级管理员角色自动获管理权限;其他运营角色通过角色管理显式分配,Telegram映射用户亦需review权限。 +INSERT INTO sys_role_menu(role_id,menu_id) +SELECT r.role_id,m.menu_id FROM sys_role r JOIN sys_menu m ON m.perms IN ('rent:withdraw:list','rent:withdraw:review','rent:withdraw:execute') +WHERE r.role_key='admin' AND NOT EXISTS(SELECT 1 FROM sys_role_menu x WHERE x.role_id=r.role_id AND x.menu_id=m.menu_id); +COMMIT; diff --git a/sql/rent_withdraw_migration.sql b/sql/rent_withdraw_migration.sql new file mode 100644 index 0000000..a76b3b6 --- /dev/null +++ b/sql/rent_withdraw_migration.sql @@ -0,0 +1,94 @@ +-- 租赁提现新增表。重复执行不覆盖历史数据;先部署这些表,再开启提现配置。 +CREATE TABLE IF NOT EXISTS rent_withdraw_order ( + id BIGINT NOT NULL AUTO_INCREMENT, + withdraw_no VARCHAR(40) NOT NULL COMMENT '系统提现编号', + user_id BIGINT NOT NULL, + account_id BIGINT NOT NULL, + network VARCHAR(16) NOT NULL, + client_request_no VARCHAR(64) NOT NULL, + request_hash VARCHAR(64) NOT NULL, + receiver_address VARCHAR(64) NOT NULL, + amount DECIMAL(30,6) NOT NULL, + frozen_amount DECIMAL(30,6) NOT NULL, + status VARCHAR(24) NOT NULL COMMENT 'PENDING_REVIEW、EXECUTING、VERIFYING、MANUAL_REVIEW、REJECTED、COMPLETED', + active_user_id BIGINT NULL COMMENT '全网络同用户仅允许一笔在途,终结置NULL', + payout_sender_snapshot TEXT NULL COMMENT '审核时允许付款地址JSON快照,不含私钥', + review_channel VARCHAR(16) NULL, + reviewer_user_id BIGINT NULL, + reviewer_telegram_id VARCHAR(64) NULL, + review_reason VARCHAR(512) NULL, + approved_at DATETIME(3) NULL, + reviewed_at DATETIME(3) NULL, + arrival_mode VARCHAR(16) NULL COMMENT 'MANUAL或AUTO,最终完成时锁定', + arrival_transaction_id BIGINT NULL, + arrival_operator_id BIGINT NULL, + arrival_remark VARCHAR(512) NULL, + completed_at DATETIME(3) NULL, + remark VARCHAR(512) NOT NULL DEFAULT '', + last_check_at DATETIME(3) NULL, + last_error VARCHAR(512) NULL COMMENT '固定脱敏提示,不保存异常原文', + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_no(withdraw_no), + UNIQUE KEY uk_withdraw_request(user_id,client_request_no), + UNIQUE KEY uk_withdraw_active_user(active_user_id), + KEY idx_withdraw_user(user_id,network,id), + KEY idx_withdraw_pending(status,network,id) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='租赁可用余额提现审核单'; + +CREATE TABLE IF NOT EXISTS rent_withdraw_transaction ( + id BIGINT NOT NULL AUTO_INCREMENT, + network VARCHAR(16) NOT NULL, + transaction_id VARCHAR(64) NOT NULL, + log_index INT NOT NULL, + token_contract VARCHAR(64) NOT NULL, + from_address VARCHAR(64) NOT NULL, + to_address VARCHAR(64) NOT NULL, + amount_units DECIMAL(65,0) NOT NULL, + amount_usdt DECIMAL(65,6) NOT NULL, + block_number BIGINT NOT NULL, + block_hash VARCHAR(64) NULL, + block_time DATETIME(3) NOT NULL, + discovery_source VARCHAR(24) NOT NULL, + verify_status VARCHAR(24) NOT NULL, + match_status VARCHAR(24) NOT NULL, + withdraw_id BIGINT NULL COMMENT '唯一认领的提现单', + evidence TEXT NOT NULL COMMENT '筛选后的证据摘要,不存完整交易或认证数据', + last_checked_at DATETIME(3) NOT NULL, + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_chain_event(network,transaction_id,log_index), + UNIQUE KEY uk_withdraw_claim(withdraw_id), + KEY idx_withdraw_tx_match(network,to_address,match_status,block_time) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='手动提交及自动监听的已确认USDT事件'; + +CREATE TABLE IF NOT EXISTS rent_withdraw_scan_cursor ( + id BIGINT NOT NULL AUTO_INCREMENT, + network VARCHAR(16) NOT NULL, + last_block BIGINT NOT NULL, + lock_owner VARCHAR(64) NULL, + lock_until DATETIME(3) NULL, + last_error VARCHAR(512) NULL, + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_scan_network(network) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='提现自动扫描断点及多实例租约'; + +-- 存量账本只新增可空关联,不重算历史余额。 +DROP PROCEDURE IF EXISTS rent_add_withdraw_ledger; +DELIMITER $$ +CREATE PROCEDURE rent_add_withdraw_ledger() +BEGIN + IF NOT EXISTS(SELECT 1 FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='rent_ledger' AND COLUMN_NAME='withdraw_id') THEN + ALTER TABLE rent_ledger ADD COLUMN withdraw_id BIGINT NULL COMMENT '提现单关联'; + END IF; +END$$ +DELIMITER ; +CALL rent_add_withdraw_ledger(); +DROP PROCEDURE rent_add_withdraw_ledger; diff --git a/sql/rent_withdraw_tables.sql b/sql/rent_withdraw_tables.sql new file mode 100644 index 0000000..6c853bc --- /dev/null +++ b/sql/rent_withdraw_tables.sql @@ -0,0 +1,81 @@ +-- 租赁提现新增表。重复执行不覆盖历史数据;先部署这些表,再开启提现配置。 +CREATE TABLE IF NOT EXISTS rent_withdraw_order ( + id BIGINT NOT NULL AUTO_INCREMENT, + withdraw_no VARCHAR(40) NOT NULL COMMENT '系统提现编号', + user_id BIGINT NOT NULL, + account_id BIGINT NOT NULL, + network VARCHAR(16) NOT NULL, + client_request_no VARCHAR(64) NOT NULL, + request_hash VARCHAR(64) NOT NULL, + receiver_address VARCHAR(64) NOT NULL, + amount DECIMAL(30,6) NOT NULL, + frozen_amount DECIMAL(30,6) NOT NULL, + status VARCHAR(24) NOT NULL COMMENT 'PENDING_REVIEW、EXECUTING、VERIFYING、MANUAL_REVIEW、REJECTED、COMPLETED', + active_user_id BIGINT NULL COMMENT '全网络同用户仅允许一笔在途,终结置NULL', + payout_sender_snapshot TEXT NULL COMMENT '审核时允许付款地址JSON快照,不含私钥', + review_channel VARCHAR(16) NULL, + reviewer_user_id BIGINT NULL, + reviewer_telegram_id VARCHAR(64) NULL, + review_reason VARCHAR(512) NULL, + approved_at DATETIME(3) NULL, + reviewed_at DATETIME(3) NULL, + arrival_mode VARCHAR(16) NULL COMMENT 'MANUAL或AUTO,最终完成时锁定', + arrival_transaction_id BIGINT NULL, + arrival_operator_id BIGINT NULL, + arrival_remark VARCHAR(512) NULL, + completed_at DATETIME(3) NULL, + remark VARCHAR(512) NOT NULL DEFAULT '', + last_check_at DATETIME(3) NULL, + last_error VARCHAR(512) NULL COMMENT '固定脱敏提示,不保存异常原文', + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_no(withdraw_no), + UNIQUE KEY uk_withdraw_request(user_id,client_request_no), + UNIQUE KEY uk_withdraw_active_user(active_user_id), + KEY idx_withdraw_user(user_id,network,id), + KEY idx_withdraw_pending(status,network,id) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='租赁可用余额提现审核单'; + +CREATE TABLE IF NOT EXISTS rent_withdraw_transaction ( + id BIGINT NOT NULL AUTO_INCREMENT, + network VARCHAR(16) NOT NULL, + transaction_id VARCHAR(64) NOT NULL, + log_index INT NOT NULL, + token_contract VARCHAR(64) NOT NULL, + from_address VARCHAR(64) NOT NULL, + to_address VARCHAR(64) NOT NULL, + amount_units DECIMAL(65,0) NOT NULL, + amount_usdt DECIMAL(65,6) NOT NULL, + block_number BIGINT NOT NULL, + block_hash VARCHAR(64) NULL, + block_time DATETIME(3) NOT NULL, + discovery_source VARCHAR(24) NOT NULL, + verify_status VARCHAR(24) NOT NULL, + match_status VARCHAR(24) NOT NULL, + withdraw_id BIGINT NULL COMMENT '唯一认领的提现单', + evidence TEXT NOT NULL COMMENT '筛选后的证据摘要,不存完整交易或认证数据', + last_checked_at DATETIME(3) NOT NULL, + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_chain_event(network,transaction_id,log_index), + UNIQUE KEY uk_withdraw_claim(withdraw_id), + KEY idx_withdraw_tx_match(network,to_address,match_status,block_time) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='手动提交及自动监听的已确认USDT事件'; + +CREATE TABLE IF NOT EXISTS rent_withdraw_scan_cursor ( + id BIGINT NOT NULL AUTO_INCREMENT, + network VARCHAR(16) NOT NULL, + last_block BIGINT NOT NULL, + lock_owner VARCHAR(64) NULL, + lock_until DATETIME(3) NULL, + last_error VARCHAR(512) NULL, + version BIGINT NOT NULL DEFAULT 0, + created_at DATETIME(3) NOT NULL, + updated_at DATETIME(3) NOT NULL, + PRIMARY KEY(id), + UNIQUE KEY uk_withdraw_scan_network(network) +) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='提现自动扫描断点及多实例租约';