hailin
/
rwadurian
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat(withdrawal): implement withdrawal order and fund allocation system 

- Add SystemAccount domain in authorization-service for managing regional/company accounts
- Implement fund allocation service in planting-service with multi-tier distribution
- Add WithdrawalOrder aggregate in wallet-service with full lifecycle management
- Create internal wallet controller for cross-service fund allocation
- Add Kafka event publishing for withdrawal requests
- Implement unit-of-work pattern for transactional consistency
- Update Prisma schemas with withdrawal order and system account tables

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
hailin 2025-12-09 02:35:27 -08:00
parent 001b6501a0
commit 781721a659
44 changed files with 3265 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
backend/services/authorization-service/prisma/schema.prisma
View File

@ -372,3 +372,93 @@ enum RegionType {
PROVINCE // 省
CITY // 市
}
// ============ 系统账户类型枚举 ============
enum SystemAccountType {
COST_ACCOUNT // 成本账户
OPERATION_ACCOUNT // 运营账户
HQ_COMMUNITY // 总部社区账户
RWAD_POOL_PENDING // RWAD矿池待注入
SYSTEM_PROVINCE // 系统省账户（无授权时）
SYSTEM_CITY // 系统市账户（无授权时）
}
// ============ 系统账户流水类型枚举 ============
enum SystemLedgerEntryType {
PLANTING_ALLOCATION // 认种分配收入
REWARD_EXPIRED // 过期奖励收入
TRANSFER_OUT // 转出
TRANSFER_IN // 转入
WITHDRAWAL // 提现
ADJUSTMENT // 调整
}
// ============ 系统账户表 ============
// 管理成本、运营、总部社区、矿池等系统级账户
model SystemAccount {
id BigInt @id @default(autoincrement()) @map("account_id")
// 账户类型
accountType SystemAccountType @map("account_type")
// 区域信息（仅 SYSTEM_PROVINCE/SYSTEM_CITY 需要）
regionCode String? @map("region_code") @db.VarChar(10)
regionName String? @map("region_name") @db.VarChar(50)
// MPC 生成的钱包地址（按需生成）
walletAddress String? @map("wallet_address") @db.VarChar(42)
mpcPublicKey String? @map("mpc_public_key") @db.VarChar(130)
// 余额（USDT）
usdtBalance Decimal @default(0) @map("usdt_balance") @db.Decimal(20, 8)
// 算力（仅用于省市账户的算力分配）
hashpower Decimal @default(0) @map("hashpower") @db.Decimal(20, 8)
// 累计统计
totalReceived Decimal @default(0) @map("total_received") @db.Decimal(20, 8)
totalTransferred Decimal @default(0) @map("total_transferred") @db.Decimal(20, 8)
// 状态
status String @default("ACTIVE") @map("status") @db.VarChar(20)
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
ledgerEntries SystemAccountLedger[]
@@unique([accountType, regionCode], name: "uk_account_region")
@@index([accountType], name: "idx_system_account_type")
@@index([walletAddress], name: "idx_system_wallet_address")
@@map("system_accounts")
}
// ============ 系统账户流水表 ============
// 记录系统账户的所有资金变动（Append-only）
model SystemAccountLedger {
id BigInt @id @default(autoincrement()) @map("ledger_id")
accountId BigInt @map("account_id")
// 流水类型
entryType SystemLedgerEntryType @map("entry_type")
// 金额
amount Decimal @map("amount") @db.Decimal(20, 8)
balanceAfter Decimal @map("balance_after") @db.Decimal(20, 8)
// 关联信息
sourceOrderId BigInt? @map("source_order_id") // 来源认种订单
sourceRewardId BigInt? @map("source_reward_id") // 来源过期奖励
txHash String? @map("tx_hash") @db.VarChar(66) // 链上交易哈希
memo String? @map("memo") @db.VarChar(500)
createdAt DateTime @default(now()) @map("created_at")
account SystemAccount @relation(fields: [accountId], references: [id])
@@index([accountId, createdAt(sort: Desc)], name: "idx_system_ledger_account_created")
@@index([sourceOrderId], name: "idx_system_ledger_source_order")
@@index([txHash], name: "idx_system_ledger_tx_hash")
@@map("system_account_ledgers")
}

1
backend/services/authorization-service/src/application/services/index.ts
View File

@ -1 +1,2 @@
export * from './authorization-application.service'
export * from './system-account-application.service'

437
backend/services/authorization-service/src/application/services/system-account-application.service.ts Normal file
View File

@ -0,0 +1,437 @@
import { Injectable, Inject, Logger, OnModuleInit } from '@nestjs/common'
import { SystemAccount, SystemAccountLedgerEntryProps } from '@/domain/aggregates'
import {
SystemAccountType,
SystemLedgerEntryType,
SystemAccountStatus,
} from '@/domain/enums'
import {
ISystemAccountRepository,
SYSTEM_ACCOUNT_REPOSITORY,
} from '@/domain/repositories'
import { EventPublisherService } from '@/infrastructure/kafka'
import { ApplicationError, NotFoundError } from '@/shared/exceptions'
import Decimal from 'decimal.js'
// 系统账户 DTO
export interface SystemAccountDTO {
id: string
accountType: SystemAccountType
regionCode: string | null
regionName: string | null
walletAddress: string | null
usdtBalance: string
hashpower: string
totalReceived: string
totalTransferred: string
status: string
createdAt: Date
updatedAt: Date
}
// 系统账户流水 DTO
export interface SystemAccountLedgerDTO {
id: string
accountId: string
entryType: SystemLedgerEntryType
amount: string
balanceAfter: string
sourceOrderId: string | null
txHash: string | null
memo: string | null
createdAt: Date
}
// 分配目标接口
export interface AllocationTarget {
targetType: string
targetUserId?: string // 用户账户
targetSystemAccountId?: bigint // 系统账户
amount: Decimal
hashpowerPercent?: Decimal
}
// 分配请求
export interface ReceiveFundsRequest {
accountId: bigint
amount: Decimal
entryType: SystemLedgerEntryType
sourceOrderId?: bigint
sourceRewardId?: bigint
txHash?: string
memo?: string
}
@Injectable()
export class SystemAccountApplicationService implements OnModuleInit {
private readonly logger = new Logger(SystemAccountApplicationService.name)
constructor(
@Inject(SYSTEM_ACCOUNT_REPOSITORY)
private readonly systemAccountRepository: ISystemAccountRepository,
private readonly eventPublisher: EventPublisherService,
) {}
/**
* 模块初始化时初始化固定系统账户
*/
async onModuleInit(): Promise<void> {
await this.initializeFixedAccounts()
}
/**
* 初始化固定系统账户
*/
async initializeFixedAccounts(): Promise<void> {
const fixedAccountTypes = [
SystemAccountType.COST_ACCOUNT,
SystemAccountType.OPERATION_ACCOUNT,
SystemAccountType.HQ_COMMUNITY,
SystemAccountType.RWAD_POOL_PENDING,
]
for (const accountType of fixedAccountTypes) {
try {
await this.systemAccountRepository.getOrCreate(accountType)
this.logger.log(`初始化系统账户: ${accountType}`)
} catch (error) {
this.logger.error(`初始化系统账户失败: ${accountType}`, error)
}
}
}
/**
* 获取或创建系统账户（用于按需生成区域账户）
*/
async getOrCreateSystemAccount(
accountType: SystemAccountType,
regionCode?: string,
regionName?: string,
): Promise<SystemAccountDTO> {
const account = await this.systemAccountRepository.getOrCreate(
accountType,
regionCode,
regionName,
)
return this.toDTO(account)
}
/**
* 获取系统账户通过类型
*/
async getSystemAccountByType(
accountType: SystemAccountType,
): Promise<SystemAccountDTO | null> {
const account = await this.systemAccountRepository.findByType(accountType)
return account ? this.toDTO(account) : null
}
/**
* 获取系统账户通过类型和区域
*/
async getSystemAccountByTypeAndRegion(
accountType: SystemAccountType,
regionCode: string,
): Promise<SystemAccountDTO | null> {
const account = await this.systemAccountRepository.findByTypeAndRegion(
accountType,
regionCode,
)
return account ? this.toDTO(account) : null
}
/**
* 获取所有固定系统账户
*/
async getAllFixedAccounts(): Promise<SystemAccountDTO[]> {
const accounts = await this.systemAccountRepository.findAllFixedAccounts()
return accounts.map((a) => this.toDTO(a))
}
/**
* 确保系统账户有钱包地址（按需生成 MPC 地址）
*/
async ensureWalletAddress(accountId: bigint): Promise<string> {
const account = await this.systemAccountRepository.findById(accountId)
if (!account) {
throw new NotFoundError('系统账户不存在')
}
if (account.walletAddress) {
return account.walletAddress
}
// TODO: 调用 MPC 服务生成地址
// 此处需要集成 MPC 服务，暂时抛出错误
throw new ApplicationError('系统账户钱包地址尚未生成，请联系管理员')
}
/**
* 设置系统账户钱包地址（由 MPC 服务调用）
*/
async setWalletAddress(
accountId: bigint,
walletAddress: string,
mpcPublicKey: string,
): Promise<void> {
const account = await this.systemAccountRepository.findById(accountId)
if (!account) {
throw new NotFoundError('系统账户不存在')
}
account.setWalletAddress(walletAddress, mpcPublicKey)
await this.systemAccountRepository.save(account)
await this.eventPublisher.publishAll(account.domainEvents)
account.clearDomainEvents()
this.logger.log(
`系统账户 ${account.accountType} 设置钱包地址: ${walletAddress}`,
)
}
/**
* 系统账户接收资金
*/
async receiveFunds(request: ReceiveFundsRequest): Promise<void> {
const account = await this.systemAccountRepository.findById(request.accountId)
if (!account) {
throw new NotFoundError('系统账户不存在')
}
const ledgerEntry = account.receiveFunds({
amount: request.amount,
entryType: request.entryType,
sourceOrderId: request.sourceOrderId,
sourceRewardId: request.sourceRewardId,
txHash: request.txHash,
memo: request.memo,
})
// 保存账户和流水
await this.systemAccountRepository.save(account)
await this.systemAccountRepository.saveLedgerEntry(ledgerEntry)
await this.eventPublisher.publishAll(account.domainEvents)
account.clearDomainEvents()
this.logger.log(
`系统账户 ${account.accountType} 收到 ${request.amount.toString()} USDT`,
)
}
/**
* 批量接收资金（用于认种分配）
*/
async batchReceiveFunds(requests: ReceiveFundsRequest[]): Promise<void> {
for (const request of requests) {
await this.receiveFunds(request)
}
}
/**
* 系统账户转出资金
*/
async transferFunds(
accountId: bigint,
amount: Decimal,
txHash?: string,
memo?: string,
): Promise<void> {
const account = await this.systemAccountRepository.findById(accountId)
if (!account) {
throw new NotFoundError('系统账户不存在')
}
const ledgerEntry = account.transferFunds({
amount,
txHash,
memo,
})
await this.systemAccountRepository.save(account)
await this.systemAccountRepository.saveLedgerEntry(ledgerEntry)
await this.eventPublisher.publishAll(account.domainEvents)
account.clearDomainEvents()
this.logger.log(
`系统账户 ${account.accountType} 转出 ${amount.toString()} USDT`,
)
}
/**
* 查询系统账户流水
*/
async getAccountLedgerEntries(
accountId: bigint,
limit?: number,
offset?: number,
): Promise<SystemAccountLedgerDTO[]> {
const entries = await this.systemAccountRepository.findLedgerEntriesByAccountId(
accountId,
limit,
offset,
)
return entries.map((entry) => this.toLedgerDTO(entry))
}
/**
* 计算认种分配目标（基于授权状态）
* 这个方法用于 planting-service 调用，确定分配目标
*/
async calculateAllocationTargets(params: {
planterId: string
treeCount: number
provinceCode: string
cityCode: string
referrerId?: string
}): Promise<AllocationTarget[]> {
const allocations: AllocationTarget[] = []
const treeCount = params.treeCount
// 1. 固定系统账户分配
const costAccount = await this.systemAccountRepository.findByType(
SystemAccountType.COST_ACCOUNT,
)
const operationAccount = await this.systemAccountRepository.findByType(
SystemAccountType.OPERATION_ACCOUNT,
)
const hqCommunityAccount = await this.systemAccountRepository.findByType(
SystemAccountType.HQ_COMMUNITY,
)
const rwadPoolAccount = await this.systemAccountRepository.findByType(
SystemAccountType.RWAD_POOL_PENDING,
)
if (costAccount) {
allocations.push({
targetType: 'COST_ACCOUNT',
targetSystemAccountId: costAccount.id,
amount: new Decimal(400).mul(treeCount),
})
}
if (operationAccount) {
allocations.push({
targetType: 'OPERATION_ACCOUNT',
targetSystemAccountId: operationAccount.id,
amount: new Decimal(300).mul(treeCount),
})
}
if (hqCommunityAccount) {
allocations.push({
targetType: 'HQ_COMMUNITY',
targetSystemAccountId: hqCommunityAccount.id,
amount: new Decimal(9).mul(treeCount),
})
}
if (rwadPoolAccount) {
allocations.push({
targetType: 'RWAD_POOL',
targetSystemAccountId: rwadPoolAccount.id,
amount: new Decimal(800).mul(treeCount),
})
}
// 2. 直接推荐人（500 USDT）
if (params.referrerId) {
allocations.push({
targetType: 'DIRECT_REFERRER',
targetUserId: params.referrerId,
amount: new Decimal(500).mul(treeCount),
})
} else if (operationAccount) {
// 无推荐人，归入运营账户
allocations.push({
targetType: 'OPERATION_ACCOUNT',
targetSystemAccountId: operationAccount.id,
amount: new Decimal(500).mul(treeCount),
})
}
// 3. 省公司权益（15 区域 + 20 团队）
// TODO: 从 authorization-service 查询省公司授权状态
// 暂时归入系统省账户
const systemProvince = await this.systemAccountRepository.getOrCreate(
SystemAccountType.SYSTEM_PROVINCE,
params.provinceCode,
params.provinceCode,
)
allocations.push({
targetType: 'PROVINCE_REGION',
targetSystemAccountId: systemProvince.id,
amount: new Decimal(15).mul(treeCount),
})
allocations.push({
targetType: 'PROVINCE_TEAM',
targetSystemAccountId: systemProvince.id,
amount: new Decimal(20).mul(treeCount),
})
// 4. 市公司权益（35 区域 + 40 团队）
// TODO: 从 authorization-service 查询市公司授权状态
// 暂时归入系统市账户
const systemCity = await this.systemAccountRepository.getOrCreate(
SystemAccountType.SYSTEM_CITY,
params.cityCode,
params.cityCode,
)
allocations.push({
targetType: 'CITY_REGION',
targetSystemAccountId: systemCity.id,
amount: new Decimal(35).mul(treeCount),
})
allocations.push({
targetType: 'CITY_TEAM',
targetSystemAccountId: systemCity.id,
amount: new Decimal(40).mul(treeCount),
})
// 5. 社区权益（80 USDT）
// TODO: 从 authorization-service 查询社区授权状态
// 暂时归入运营账户
if (operationAccount) {
allocations.push({
targetType: 'COMMUNITY',
targetSystemAccountId: operationAccount.id,
amount: new Decimal(80).mul(treeCount),
})
}
return allocations
}
// 辅助方法
private toDTO(account: SystemAccount): SystemAccountDTO {
return {
id: account.id.toString(),
accountType: account.accountType,
regionCode: account.regionCode,
regionName: account.regionName,
walletAddress: account.walletAddress,
usdtBalance: account.usdtBalance.toString(),
hashpower: account.hashpower.toString(),
totalReceived: account.totalReceived.toString(),
totalTransferred: account.totalTransferred.toString(),
status: account.status,
createdAt: account.createdAt,
updatedAt: account.updatedAt,
}
}
private toLedgerDTO(entry: SystemAccountLedgerEntryProps): SystemAccountLedgerDTO {
return {
id: entry.id.toString(),
accountId: entry.accountId.toString(),
entryType: entry.entryType,
amount: entry.amount.toString(),
balanceAfter: entry.balanceAfter.toString(),
sourceOrderId: entry.sourceOrderId?.toString() || null,
txHash: entry.txHash,
memo: entry.memo,
createdAt: entry.createdAt,
}
}
}

1
backend/services/authorization-service/src/domain/aggregates/index.ts
View File

@ -1,3 +1,4 @@
export * from './aggregate-root.base'
export * from './authorization-role.aggregate'
export * from './monthly-assessment.aggregate'
export * from './system-account.aggregate'

366
backend/services/authorization-service/src/domain/aggregates/system-account.aggregate.ts Normal file
View File

@ -0,0 +1,366 @@
import { AggregateRoot } from './aggregate-root.base'
import { SystemAccountType, SystemLedgerEntryType, SystemAccountStatus } from '@/domain/enums'
import { DomainError } from '@/shared/exceptions'
import {
SystemAccountCreatedEvent,
SystemAccountWalletGeneratedEvent,
SystemAccountFundsReceivedEvent,
SystemAccountFundsTransferredEvent,
} from '@/domain/events'
import Decimal from 'decimal.js'
export interface SystemAccountProps {
id: bigint
accountType: SystemAccountType
regionCode: string | null
regionName: string | null
walletAddress: string | null
mpcPublicKey: string | null
usdtBalance: Decimal
hashpower: Decimal
totalReceived: Decimal
totalTransferred: Decimal
status: SystemAccountStatus
createdAt: Date
updatedAt: Date
}
export interface SystemAccountLedgerEntryProps {
id: bigint
accountId: bigint
entryType: SystemLedgerEntryType
amount: Decimal
balanceAfter: Decimal
sourceOrderId: bigint | null
sourceRewardId: bigint | null
txHash: string | null
memo: string | null
createdAt: Date
}
export class SystemAccount extends AggregateRoot {
private _id: bigint
private _accountType: SystemAccountType
private _regionCode: string | null
private _regionName: string | null
private _walletAddress: string | null
private _mpcPublicKey: string | null
private _usdtBalance: Decimal
private _hashpower: Decimal
private _totalReceived: Decimal
private _totalTransferred: Decimal
private _status: SystemAccountStatus
private _createdAt: Date
private _updatedAt: Date
// Getters
get id(): bigint {
return this._id
}
get accountType(): SystemAccountType {
return this._accountType
}
get regionCode(): string | null {
return this._regionCode
}
get regionName(): string | null {
return this._regionName
}
get walletAddress(): string | null {
return this._walletAddress
}
get mpcPublicKey(): string | null {
return this._mpcPublicKey
}
get usdtBalance(): Decimal {
return this._usdtBalance
}
get hashpower(): Decimal {
return this._hashpower
}
get totalReceived(): Decimal {
return this._totalReceived
}
get totalTransferred(): Decimal {
return this._totalTransferred
}
get status(): SystemAccountStatus {
return this._status
}
get createdAt(): Date {
return this._createdAt
}
get updatedAt(): Date {
return this._updatedAt
}
get isActive(): boolean {
return this._status === SystemAccountStatus.ACTIVE
}
get hasWallet(): boolean {
return this._walletAddress !== null
}
// 私有构造函数
private constructor(props: SystemAccountProps) {
super()
this._id = props.id
this._accountType = props.accountType
this._regionCode = props.regionCode
this._regionName = props.regionName
this._walletAddress = props.walletAddress
this._mpcPublicKey = props.mpcPublicKey
this._usdtBalance = props.usdtBalance
this._hashpower = props.hashpower
this._totalReceived = props.totalReceived
this._totalTransferred = props.totalTransferred
this._status = props.status
this._createdAt = props.createdAt
this._updatedAt = props.updatedAt
}
// 工厂方法 - 从数据库重建
static fromPersistence(props: SystemAccountProps): SystemAccount {
return new SystemAccount(props)
}
// 工厂方法 - 创建固定系统账户（成本、运营、总部社区、矿池）
static createFixedAccount(accountType: SystemAccountType): SystemAccount {
if (
accountType === SystemAccountType.SYSTEM_PROVINCE ||
accountType === SystemAccountType.SYSTEM_CITY
) {
throw new DomainError('区域系统账户需要指定区域信息')
}
const account = new SystemAccount({
id: BigInt(0), // 由数据库生成
accountType,
regionCode: null,
regionName: null,
walletAddress: null,
mpcPublicKey: null,
usdtBalance: new Decimal(0),
hashpower: new Decimal(0),
totalReceived: new Decimal(0),
totalTransferred: new Decimal(0),
status: SystemAccountStatus.ACTIVE,
createdAt: new Date(),
updatedAt: new Date(),
})
account.addDomainEvent(
new SystemAccountCreatedEvent({
accountType,
regionCode: null,
}),
)
return account
}
// 工厂方法 - 创建区域系统账户（省/市）
static createRegionAccount(params: {
accountType: SystemAccountType.SYSTEM_PROVINCE | SystemAccountType.SYSTEM_CITY
regionCode: string
regionName: string
}): SystemAccount {
const account = new SystemAccount({
id: BigInt(0), // 由数据库生成
accountType: params.accountType,
regionCode: params.regionCode,
regionName: params.regionName,
walletAddress: null,
mpcPublicKey: null,
usdtBalance: new Decimal(0),
hashpower: new Decimal(0),
totalReceived: new Decimal(0),
totalTransferred: new Decimal(0),
status: SystemAccountStatus.ACTIVE,
createdAt: new Date(),
updatedAt: new Date(),
})
account.addDomainEvent(
new SystemAccountCreatedEvent({
accountType: params.accountType,
regionCode: params.regionCode,
}),
)
return account
}
// 核心领域行为
/**
* 设置 MPC 生成的钱包地址
*/
setWalletAddress(walletAddress: string, mpcPublicKey: string): void {
if (this._walletAddress) {
throw new DomainError('钱包地址已设置，不能重复设置')
}
this._walletAddress = walletAddress
this._mpcPublicKey = mpcPublicKey
this._updatedAt = new Date()
this.addDomainEvent(
new SystemAccountWalletGeneratedEvent({
accountId: this._id.toString(),
accountType: this._accountType,
walletAddress,
mpcPublicKey,
}),
)
}
/**
* 接收资金（从认种分配或过期奖励）
*/
receiveFunds(params: {
amount: Decimal
entryType: SystemLedgerEntryType
sourceOrderId?: bigint
sourceRewardId?: bigint
txHash?: string
memo?: string
}): SystemAccountLedgerEntryProps {
if (!this.isActive) {
throw new DomainError('系统账户已停用')
}
if (params.amount.lte(0)) {
throw new DomainError('金额必须大于0')
}
const newBalance = this._usdtBalance.plus(params.amount)
this._usdtBalance = newBalance
this._totalReceived = this._totalReceived.plus(params.amount)
this._updatedAt = new Date()
const ledgerEntry: SystemAccountLedgerEntryProps = {
id: BigInt(0), // 由数据库生成
accountId: this._id,
entryType: params.entryType,
amount: params.amount,
balanceAfter: newBalance,
sourceOrderId: params.sourceOrderId || null,
sourceRewardId: params.sourceRewardId || null,
txHash: params.txHash || null,
memo: params.memo || null,
createdAt: new Date(),
}
this.addDomainEvent(
new SystemAccountFundsReceivedEvent({
accountId: this._id.toString(),
accountType: this._accountType,
amount: params.amount.toString(),
entryType: params.entryType,
balanceAfter: newBalance.toString(),
}),
)
return ledgerEntry
}
/**
* 转出资金
*/
transferFunds(params: {
amount: Decimal
txHash?: string
memo?: string
}): SystemAccountLedgerEntryProps {
if (!this.isActive) {
throw new DomainError('系统账户已停用')
}
if (params.amount.lte(0)) {
throw new DomainError('金额必须大于0')
}
if (this._usdtBalance.lt(params.amount)) {
throw new DomainError('余额不足')
}
const newBalance = this._usdtBalance.minus(params.amount)
this._usdtBalance = newBalance
this._totalTransferred = this._totalTransferred.plus(params.amount)
this._updatedAt = new Date()
const ledgerEntry: SystemAccountLedgerEntryProps = {
id: BigInt(0),
accountId: this._id,
entryType: SystemLedgerEntryType.TRANSFER_OUT,
amount: params.amount.neg(),
balanceAfter: newBalance,
sourceOrderId: null,
sourceRewardId: null,
txHash: params.txHash || null,
memo: params.memo || null,
createdAt: new Date(),
}
this.addDomainEvent(
new SystemAccountFundsTransferredEvent({
accountId: this._id.toString(),
accountType: this._accountType,
amount: params.amount.toString(),
txHash: params.txHash || null,
balanceAfter: newBalance.toString(),
}),
)
return ledgerEntry
}
/**
* 增加算力
*/
addHashpower(amount: Decimal): void {
if (amount.lte(0)) {
throw new DomainError('算力必须大于0')
}
this._hashpower = this._hashpower.plus(amount)
this._updatedAt = new Date()
}
/**
* 停用账户
*/
deactivate(): void {
this._status = SystemAccountStatus.INACTIVE
this._updatedAt = new Date()
}
/**
* 激活账户
*/
activate(): void {
this._status = SystemAccountStatus.ACTIVE
this._updatedAt = new Date()
}
/**
* 转换为持久化数据
*/
toPersistence(): Record<string, any> {
return {
id: this._id,
accountType: this._accountType,
regionCode: this._regionCode,
regionName: this._regionName,
walletAddress: this._walletAddress,
mpcPublicKey: this._mpcPublicKey,
usdtBalance: this._usdtBalance,
hashpower: this._hashpower,
totalReceived: this._totalReceived,
totalTransferred: this._totalTransferred,
status: this._status,
createdAt: this._createdAt,
updatedAt: this._updatedAt,
}
}
}

26
backend/services/authorization-service/src/domain/enums/index.ts
View File

@ -48,3 +48,29 @@ export enum RegionType {
PROVINCE = 'PROVINCE',
CITY = 'CITY',
}
// 系统账户类型
export enum SystemAccountType {
COST_ACCOUNT = 'COST_ACCOUNT', // 成本账户
OPERATION_ACCOUNT = 'OPERATION_ACCOUNT', // 运营账户
HQ_COMMUNITY = 'HQ_COMMUNITY', // 总部社区账户
RWAD_POOL_PENDING = 'RWAD_POOL_PENDING', // RWAD矿池待注入
SYSTEM_PROVINCE = 'SYSTEM_PROVINCE', // 系统省账户（无授权时）
SYSTEM_CITY = 'SYSTEM_CITY', // 系统市账户（无授权时）
}
// 系统账户流水类型
export enum SystemLedgerEntryType {
PLANTING_ALLOCATION = 'PLANTING_ALLOCATION', // 认种分配收入
REWARD_EXPIRED = 'REWARD_EXPIRED', // 过期奖励收入
TRANSFER_OUT = 'TRANSFER_OUT', // 转出
TRANSFER_IN = 'TRANSFER_IN', // 转入
WITHDRAWAL = 'WITHDRAWAL', // 提现
ADJUSTMENT = 'ADJUSTMENT', // 调整
}
// 系统账户状态
export enum SystemAccountStatus {
ACTIVE = 'ACTIVE',
INACTIVE = 'INACTIVE',
}

1
backend/services/authorization-service/src/domain/events/index.ts
View File

@ -1,3 +1,4 @@
export * from './domain-event.base'
export * from './authorization-events'
export * from './assessment-events'
export * from './system-account-events'

91
backend/services/authorization-service/src/domain/events/system-account-events.ts Normal file
View File

@ -0,0 +1,91 @@
import { DomainEvent } from './domain-event.base'
import { SystemAccountType, SystemLedgerEntryType } from '@/domain/enums'
// 系统账户创建事件
export class SystemAccountCreatedEvent extends DomainEvent {
readonly eventType = 'SystemAccountCreated'
readonly aggregateId: string
readonly payload: {
accountType: SystemAccountType
regionCode: string | null
}
constructor(params: { accountType: SystemAccountType; regionCode: string | null }) {
super()
this.aggregateId = `${params.accountType}:${params.regionCode || 'global'}`
this.payload = params
}
}
// 系统账户钱包生成事件
export class SystemAccountWalletGeneratedEvent extends DomainEvent {
readonly eventType = 'SystemAccountWalletGenerated'
readonly aggregateId: string
readonly payload: {
accountId: string
accountType: SystemAccountType
walletAddress: string
mpcPublicKey: string
}
constructor(params: {
accountId: string
accountType: SystemAccountType
walletAddress: string
mpcPublicKey: string
}) {
super()
this.aggregateId = params.accountId
this.payload = params
}
}
// 系统账户收到资金事件
export class SystemAccountFundsReceivedEvent extends DomainEvent {
readonly eventType = 'SystemAccountFundsReceived'
readonly aggregateId: string
readonly payload: {
accountId: string
accountType: SystemAccountType
amount: string
entryType: SystemLedgerEntryType
balanceAfter: string
}
constructor(params: {
accountId: string
accountType: SystemAccountType
amount: string
entryType: SystemLedgerEntryType
balanceAfter: string
}) {
super()
this.aggregateId = params.accountId
this.payload = params
}
}
// 系统账户转出资金事件
export class SystemAccountFundsTransferredEvent extends DomainEvent {
readonly eventType = 'SystemAccountFundsTransferred'
readonly aggregateId: string
readonly payload: {
accountId: string
accountType: SystemAccountType
amount: string
txHash: string | null
balanceAfter: string
}
constructor(params: {
accountId: string
accountType: SystemAccountType
amount: string
txHash: string | null
balanceAfter: string
}) {
super()
this.aggregateId = params.accountId
this.payload = params
}
}

1
backend/services/authorization-service/src/domain/repositories/index.ts
View File

@ -1,3 +1,4 @@
export * from './authorization-role.repository'
export * from './monthly-assessment.repository'
export * from './planting-restriction.repository'
export * from './system-account.repository'

50
backend/services/authorization-service/src/domain/repositories/system-account.repository.ts Normal file
View File

@ -0,0 +1,50 @@
import { SystemAccount, SystemAccountLedgerEntryProps } from '@/domain/aggregates'
import { SystemAccountType } from '@/domain/enums'
export const SYSTEM_ACCOUNT_REPOSITORY = Symbol('ISystemAccountRepository')
export interface ISystemAccountRepository {
// 基础 CRUD
save(account: SystemAccount): Promise<SystemAccount>
findById(id: bigint): Promise<SystemAccount | null>
// 按类型查询
findByType(accountType: SystemAccountType): Promise<SystemAccount | null>
findByTypeAndRegion(
accountType: SystemAccountType,
regionCode: string,
): Promise<SystemAccount | null>
// 获取或创建（用于按需生成区域系统账户）
getOrCreate(
accountType: SystemAccountType,
regionCode?: string,
regionName?: string,
): Promise<SystemAccount>
// 获取所有固定系统账户
findAllFixedAccounts(): Promise<SystemAccount[]>
// 获取所有区域系统账户
findAllRegionAccounts(
accountType: SystemAccountType.SYSTEM_PROVINCE | SystemAccountType.SYSTEM_CITY,
): Promise<SystemAccount[]>
// 通过钱包地址查询
findByWalletAddress(walletAddress: string): Promise<SystemAccount | null>
// 更新钱包地址
updateWalletAddress(
id: bigint,
walletAddress: string,
mpcPublicKey: string,
): Promise<void>
// 流水相关
saveLedgerEntry(entry: SystemAccountLedgerEntryProps): Promise<bigint>
findLedgerEntriesByAccountId(
accountId: bigint,
limit?: number,
offset?: number,
): Promise<SystemAccountLedgerEntryProps[]>
}

1
backend/services/authorization-service/src/infrastructure/persistence/repositories/index.ts
View File

@ -1,2 +1,3 @@
export * from './authorization-role.repository.impl'
export * from './monthly-assessment.repository.impl'
export * from './system-account.repository.impl'

244
backend/services/authorization-service/src/infrastructure/persistence/repositories/system-account.repository.impl.ts Normal file
View File

@ -0,0 +1,244 @@
import { Injectable } from '@nestjs/common'
import { PrismaService } from '../prisma/prisma.service'
import {
ISystemAccountRepository,
SYSTEM_ACCOUNT_REPOSITORY,
} from '@/domain/repositories'
import { SystemAccount, SystemAccountProps, SystemAccountLedgerEntryProps } from '@/domain/aggregates'
import {
SystemAccountType,
SystemLedgerEntryType,
SystemAccountStatus,
} from '@/domain/enums'
import Decimal from 'decimal.js'
@Injectable()
export class SystemAccountRepositoryImpl implements ISystemAccountRepository {
constructor(private readonly prisma: PrismaService) {}
async save(account: SystemAccount): Promise<SystemAccount> {
const data = account.toPersistence()
const record = await this.prisma.systemAccount.upsert({
where: {
uk_account_region: {
accountType: data.accountType,
regionCode: data.regionCode,
},
},
create: {
accountType: data.accountType,
regionCode: data.regionCode,
regionName: data.regionName,
walletAddress: data.walletAddress,
mpcPublicKey: data.mpcPublicKey,
usdtBalance: data.usdtBalance,
hashpower: data.hashpower,
totalReceived: data.totalReceived,
totalTransferred: data.totalTransferred,
status: data.status,
},
update: {
regionName: data.regionName,
walletAddress: data.walletAddress,
mpcPublicKey: data.mpcPublicKey,
usdtBalance: data.usdtBalance,
hashpower: data.hashpower,
totalReceived: data.totalReceived,
totalTransferred: data.totalTransferred,
status: data.status,
},
})
return this.toDomain(record)
}
async findById(id: bigint): Promise<SystemAccount | null> {
const record = await this.prisma.systemAccount.findUnique({
where: { id },
})
return record ? this.toDomain(record) : null
}
async findByType(accountType: SystemAccountType): Promise<SystemAccount | null> {
const record = await this.prisma.systemAccount.findFirst({
where: {
accountType,
regionCode: null,
},
})
return record ? this.toDomain(record) : null
}
async findByTypeAndRegion(
accountType: SystemAccountType,
regionCode: string,
): Promise<SystemAccount | null> {
const record = await this.prisma.systemAccount.findUnique({
where: {
uk_account_region: {
accountType,
regionCode,
},
},
})
return record ? this.toDomain(record) : null
}
async getOrCreate(
accountType: SystemAccountType,
regionCode?: string,
regionName?: string,
): Promise<SystemAccount> {
// 对于固定系统账户，regionCode 为 null
const isRegionAccount =
accountType === SystemAccountType.SYSTEM_PROVINCE ||
accountType === SystemAccountType.SYSTEM_CITY
if (isRegionAccount && !regionCode) {
throw new Error('区域系统账户必须提供 regionCode')
}
// For region accounts, use the provided regionCode; otherwise null
const effectiveRegionCode = isRegionAccount ? regionCode! : null
// Find existing account - use findFirst for nullable regionCode
const existing = await this.prisma.systemAccount.findFirst({
where: {
accountType,
regionCode: effectiveRegionCode,
},
})
if (existing) {
return this.toDomain(existing)
}
// 创建新账户
const record = await this.prisma.systemAccount.create({
data: {
accountType,
regionCode: effectiveRegionCode,
regionName: isRegionAccount ? (regionName || regionCode) : null,
walletAddress: null,
mpcPublicKey: null,
usdtBalance: 0,
hashpower: 0,
totalReceived: 0,
totalTransferred: 0,
status: SystemAccountStatus.ACTIVE,
},
})
return this.toDomain(record)
}
async findAllFixedAccounts(): Promise<SystemAccount[]> {
const records = await this.prisma.systemAccount.findMany({
where: {
accountType: {
in: [
SystemAccountType.COST_ACCOUNT,
SystemAccountType.OPERATION_ACCOUNT,
SystemAccountType.HQ_COMMUNITY,
SystemAccountType.RWAD_POOL_PENDING,
],
},
},
})
return records.map((record) => this.toDomain(record))
}
async findAllRegionAccounts(
accountType: SystemAccountType.SYSTEM_PROVINCE | SystemAccountType.SYSTEM_CITY,
): Promise<SystemAccount[]> {
const records = await this.prisma.systemAccount.findMany({
where: { accountType },
})
return records.map((record) => this.toDomain(record))
}
async findByWalletAddress(walletAddress: string): Promise<SystemAccount | null> {
const record = await this.prisma.systemAccount.findFirst({
where: { walletAddress },
})
return record ? this.toDomain(record) : null
}
async updateWalletAddress(
id: bigint,
walletAddress: string,
mpcPublicKey: string,
): Promise<void> {
await this.prisma.systemAccount.update({
where: { id },
data: {
walletAddress,
mpcPublicKey,
},
})
}
async saveLedgerEntry(entry: SystemAccountLedgerEntryProps): Promise<bigint> {
const record = await this.prisma.systemAccountLedger.create({
data: {
accountId: entry.accountId,
entryType: entry.entryType,
amount: entry.amount,
balanceAfter: entry.balanceAfter,
sourceOrderId: entry.sourceOrderId,
sourceRewardId: entry.sourceRewardId,
txHash: entry.txHash,
memo: entry.memo,
},
})
return record.id
}
async findLedgerEntriesByAccountId(
accountId: bigint,
limit = 50,
offset = 0,
): Promise<SystemAccountLedgerEntryProps[]> {
const records = await this.prisma.systemAccountLedger.findMany({
where: { accountId },
orderBy: { createdAt: 'desc' },
take: limit,
skip: offset,
})
return records.map((record) => ({
id: record.id,
accountId: record.accountId,
entryType: record.entryType as SystemLedgerEntryType,
amount: new Decimal(record.amount.toString()),
balanceAfter: new Decimal(record.balanceAfter.toString()),
sourceOrderId: record.sourceOrderId,
sourceRewardId: record.sourceRewardId,
txHash: record.txHash,
memo: record.memo,
createdAt: record.createdAt,
}))
}
private toDomain(record: any): SystemAccount {
const props: SystemAccountProps = {
id: record.id,
accountType: record.accountType as SystemAccountType,
regionCode: record.regionCode,
regionName: record.regionName,
walletAddress: record.walletAddress,
mpcPublicKey: record.mpcPublicKey,
usdtBalance: new Decimal(record.usdtBalance.toString()),
hashpower: new Decimal(record.hashpower.toString()),
totalReceived: new Decimal(record.totalReceived.toString()),
totalTransferred: new Decimal(record.totalTransferred.toString()),
status: record.status as SystemAccountStatus,
createdAt: record.createdAt,
updatedAt: record.updatedAt,
}
return SystemAccount.fromPersistence(props)
}
}
export { SYSTEM_ACCOUNT_REPOSITORY }

137
backend/services/planting-service/src/application/services/planting-application.service.ts
View File

@ -15,6 +15,7 @@ import {
import { FundAllocationDomainService } from '../../domain/services/fund-allocation.service';
import { WalletServiceClient } from '../../infrastructure/external/wallet-service.client';
import { ReferralServiceClient } from '../../infrastructure/external/referral-service.client';
import { UnitOfWork, UNIT_OF_WORK } from '../../infrastructure/persistence/unit-of-work';
import { PRICE_PER_TREE } from '../../domain/value-objects/fund-allocation-target-type.enum';
// 个人最大认种数量限制
@ -60,6 +61,8 @@ export class PlantingApplicationService {
private readonly positionRepository: IPlantingPositionRepository,
@Inject(POOL_INJECTION_BATCH_REPOSITORY)
private readonly batchRepository: IPoolInjectionBatchRepository,
@Inject(UNIT_OF_WORK)
private readonly unitOfWork: UnitOfWork,
private readonly fundAllocationService: FundAllocationDomainService,
private readonly walletService: WalletServiceClient,
private readonly referralService: ReferralServiceClient,
@ -153,6 +156,10 @@ export class PlantingApplicationService {
/**
* 支付认种订单
*
* 采用"先验证后执行"模式确保数据一致性:
* 1. 验证阶段: 获取所有外部依赖数据，检查业务规则
* 2. 执行阶段: 按顺序执行所有写操作
*/
async payOrder(
orderNo: string,
@ -166,6 +173,8 @@ export class PlantingApplicationService {
targetAccountId: string | null;
}>;
}> {
// ==================== 验证阶段 ====================
// 1. 验证订单状态
const order = await this.orderRepository.findByOrderNo(orderNo);
if (!order) {
throw new Error('订单不存在');
@ -180,58 +189,101 @@ export class PlantingApplicationService {
throw new Error('请先选择并确认省市');
}
// 调用钱包服务扣款
await this.walletService.deductForPlanting({
userId: userId.toString(),
amount: order.totalAmount,
orderId: order.orderNo,
});
// 2. 验证钱包余额 (先检查，不扣款)
const balance = await this.walletService.getBalance(userId.toString());
if (balance.available < order.totalAmount) {
throw new Error(
`余额不足: 需要 ${order.totalAmount} USDT, 当前可用 ${balance.available} USDT`,
);
}
// 标记已支付
order.markAsPaid();
// 获取推荐链上下文
// 3. 获取推荐链上下文 (先获取，确保服务可用)
const referralContext = await this.referralService.getReferralContext(
userId.toString(),
selection.provinceCode,
selection.cityCode,
);
this.logger.log(`Referral context fetched: ${JSON.stringify(referralContext)}`);
// 计算资金分配
// 4. 预计算资金分配 (纯内存计算，无副作用)
const allocations = this.fundAllocationService.calculateAllocations(
order,
referralContext,
);
this.logger.log(`Fund allocations calculated: ${allocations.length} targets`);
// 分配资金
order.allocateFunds(allocations);
await this.orderRepository.save(order);
// ==================== 执行阶段 ====================
// 所有验证通过后，按顺序执行写操作
// 调用钱包服务执行资金分配
await this.walletService.allocateFunds({
// 5. 调用钱包服务扣款
await this.walletService.deductForPlanting({
userId: userId.toString(),
amount: order.totalAmount,
orderId: order.orderNo,
allocations: allocations.map((a) => a.toDTO()),
});
this.logger.log(`Wallet deducted: ${order.totalAmount} USDT for order ${order.orderNo}`);
// 更新用户持仓
const position = await this.positionRepository.getOrCreate(userId);
position.addPlanting(
order.treeCount.value,
selection.provinceCode,
selection.cityCode,
);
await this.positionRepository.save(position);
try {
// 6. 标记已支付并分配资金 (内存操作)
order.markAsPaid();
order.allocateFunds(allocations);
// 安排底池注入批次
await this.schedulePoolInjection(order);
// 7. 使用事务保存本地数据库的所有变更
// 这确保了订单状态、用户持仓、批次数据的原子性
await this.unitOfWork.executeInTransaction(async (uow) => {
// 保存订单状态
await uow.saveOrder(order);
this.logger.log(`Order paid: ${order.orderNo}`);
// 更新用户持仓
const position = await uow.getOrCreatePosition(userId);
position.addPlanting(
order.treeCount.value,
selection.provinceCode,
selection.cityCode,
);
await uow.savePosition(position);
return {
orderNo: order.orderNo,
status: order.status,
allocations: allocations.map((a) => a.toDTO()),
};
// 安排底池注入批次
const batch = await uow.findOrCreateCurrentBatch();
const poolAmount = this.fundAllocationService.getPoolInjectionAmount(
order.treeCount.value,
);
batch.addOrder(poolAmount);
await uow.saveBatch(batch);
// 计算注入时间（批次结束后）
const scheduledTime = new Date(batch.endDate);
scheduledTime.setHours(scheduledTime.getHours() + 1);
order.schedulePoolInjection(batch.id!, scheduledTime);
await uow.saveOrder(order);
});
this.logger.log(`Local database transaction committed for order ${order.orderNo}`);
// 8. 调用钱包服务执行资金分配 (外部调用，在事务外)
await this.walletService.allocateFunds({
orderId: order.orderNo,
allocations: allocations.map((a) => a.toDTO()),
});
this.logger.log(`Order paid successfully: ${order.orderNo}`);
return {
orderNo: order.orderNo,
status: order.status,
allocations: allocations.map((a) => a.toDTO()),
};
} catch (error) {
// 扣款后出错，记录错误以便后续补偿
this.logger.error(
`Payment post-deduction error for order ${order.orderNo}: ${error.message}`,
error.stack,
);
// TODO: 实现补偿机制 - 将失败的订单放入补偿队列
// 由于使用了数据库事务，如果事务内操作失败，本地数据会自动回滚
// 但扣款已完成，需要记录以便人工补偿或自动退款
throw new Error(`支付处理失败，请联系客服处理订单 ${order.orderNo}: ${error.message}`);
}
}
/**
@ -348,23 +400,4 @@ export class PlantingApplicationService {
}
}
/**
* 安排底池注入批次
*/
private async schedulePoolInjection(order: PlantingOrder): Promise<void> {
const batch = await this.batchRepository.findOrCreateCurrentBatch();
const poolAmount = this.fundAllocationService.getPoolInjectionAmount(
order.treeCount.value,
);
batch.addOrder(poolAmount);
await this.batchRepository.save(batch);
// 计算注入时间（批次结束后）
const scheduledTime = new Date(batch.endDate);
scheduledTime.setHours(scheduledTime.getHours() + 1);
order.schedulePoolInjection(batch.id!, scheduledTime);
await this.orderRepository.save(order);
}
}

183
backend/services/planting-service/src/domain/services/fund-allocation.service.ts
View File

@ -13,6 +13,39 @@ export interface ReferralContext {
nearestCommunity: string | null;
}
// 增强的授权上下文，用于支持更精确的分配
export interface EnhancedAllocationContext extends ReferralContext {
// 直接推荐人ID
directReferrerId: string | null;
// 省区域权益接收方（正式省公司或系统省账户）
provinceAreaRecipient: {
type: 'USER' | 'SYSTEM';
id: string;
hashpowerPercent: number; // 1% for 正式省公司
};
// 省团队权益接收方（授权省公司或系统省账户）
provinceTeamRecipient: {
type: 'USER' | 'SYSTEM';
id: string;
};
// 市区域权益接收方（正式市公司或系统市账户）
cityAreaRecipient: {
type: 'USER' | 'SYSTEM';
id: string;
hashpowerPercent: number; // 2% for 正式市公司
};
// 市团队权益接收方（授权市公司或系统市账户）
cityTeamRecipient: {
type: 'USER' | 'SYSTEM';
id: string;
};
// 社区权益接收方（社区授权或运营账户）
communityRecipient: {
type: 'USER' | 'SYSTEM';
id: string;
} | null;
}
@Injectable()
export class FundAllocationDomainService {
/**
@ -150,4 +183,154 @@ export class FundAllocationDomainService {
getPoolInjectionAmount(treeCount: number): number {
return FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.RWAD_POOL] * treeCount;
}
/**
* 使用增强的授权上下文计算资金分配
* 支持更精确的省市社区权益分配
*/
calculateAllocationsWithEnhancedContext(
order: PlantingOrder,
context: EnhancedAllocationContext,
): FundAllocation[] {
const treeCount = order.treeCount.value;
const allocations: FundAllocation[] = [];
const selection = order.provinceCitySelection;
if (!selection) {
throw new Error('订单未选择省市，无法计算资金分配');
}
// 1. 成本账户: 400 USDT/棵
allocations.push(
new FundAllocation(
FundAllocationTargetType.COST_ACCOUNT,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.COST_ACCOUNT] * treeCount,
'SYSTEM:COST_ACCOUNT',
),
);
// 2. 运营账户: 300 USDT/棵
allocations.push(
new FundAllocation(
FundAllocationTargetType.OPERATION_ACCOUNT,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.OPERATION_ACCOUNT] * treeCount,
'SYSTEM:OPERATION_ACCOUNT',
),
);
// 3. 总部社区: 9 USDT/棵
allocations.push(
new FundAllocation(
FundAllocationTargetType.HEADQUARTERS_COMMUNITY,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.HEADQUARTERS_COMMUNITY] * treeCount,
'SYSTEM:HQ_COMMUNITY',
),
);
// 4. 分享权益 (直推奖励): 500 USDT/棵
// 仅直推，无多级；无推荐人归入运营账户
const referralTarget = context.directReferrerId
? `USER:${context.directReferrerId}`
: 'SYSTEM:OPERATION_ACCOUNT';
allocations.push(
new FundAllocation(
FundAllocationTargetType.REFERRAL_RIGHTS,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.REFERRAL_RIGHTS] * treeCount,
referralTarget,
{
isDirectReferral: !!context.directReferrerId,
referrerId: context.directReferrerId,
},
),
);
// 5. 省区域权益: 15 USDT/棵 + 1%算力（正式省公司才有算力）
const provinceAreaTarget = context.provinceAreaRecipient.type === 'USER'
? `USER:${context.provinceAreaRecipient.id}`
: `SYSTEM:SYSTEM_PROVINCE:${selection.provinceCode}`;
allocations.push(
new FundAllocation(
FundAllocationTargetType.PROVINCE_AREA_RIGHTS,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.PROVINCE_AREA_RIGHTS] * treeCount,
provinceAreaTarget,
{
hashpowerPercent: context.provinceAreaRecipient.hashpowerPercent,
provinceCode: selection.provinceCode,
},
),
);
// 6. 省团队权益: 20 USDT/棵（授权省公司）
const provinceTeamTarget = context.provinceTeamRecipient.type === 'USER'
? `USER:${context.provinceTeamRecipient.id}`
: `SYSTEM:SYSTEM_PROVINCE:${selection.provinceCode}`;
allocations.push(
new FundAllocation(
FundAllocationTargetType.PROVINCE_TEAM_RIGHTS,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.PROVINCE_TEAM_RIGHTS] * treeCount,
provinceTeamTarget,
{ provinceCode: selection.provinceCode },
),
);
// 7. 市区域权益: 35 USDT/棵 + 2%算力（正式市公司才有算力）
const cityAreaTarget = context.cityAreaRecipient.type === 'USER'
? `USER:${context.cityAreaRecipient.id}`
: `SYSTEM:SYSTEM_CITY:${selection.cityCode}`;
allocations.push(
new FundAllocation(
FundAllocationTargetType.CITY_AREA_RIGHTS,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.CITY_AREA_RIGHTS] * treeCount,
cityAreaTarget,
{
hashpowerPercent: context.cityAreaRecipient.hashpowerPercent,
cityCode: selection.cityCode,
},
),
);
// 8. 市团队权益: 40 USDT/棵（授权市公司）
const cityTeamTarget = context.cityTeamRecipient.type === 'USER'
? `USER:${context.cityTeamRecipient.id}`
: `SYSTEM:SYSTEM_CITY:${selection.cityCode}`;
allocations.push(
new FundAllocation(
FundAllocationTargetType.CITY_TEAM_RIGHTS,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.CITY_TEAM_RIGHTS] * treeCount,
cityTeamTarget,
{ cityCode: selection.cityCode },
),
);
// 9. 社区权益: 80 USDT/棵
const communityTarget = context.communityRecipient && context.communityRecipient.type === 'USER'
? `USER:${context.communityRecipient.id}`
: 'SYSTEM:OPERATION_ACCOUNT';
allocations.push(
new FundAllocation(
FundAllocationTargetType.COMMUNITY_RIGHTS,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.COMMUNITY_RIGHTS] * treeCount,
communityTarget,
),
);
// 10. RWAD底池: 800 USDT/棵
allocations.push(
new FundAllocation(
FundAllocationTargetType.RWAD_POOL,
FUND_ALLOCATION_AMOUNTS[FundAllocationTargetType.RWAD_POOL] * treeCount,
'SYSTEM:RWAD_POOL_PENDING',
{ miningStartDelayDays: 30 },
),
);
// 验证总额
const total = allocations.reduce((sum, a) => sum + a.amount, 0);
const expected = 2199 * treeCount;
if (Math.abs(total - expected) > 0.01) {
throw new Error(`资金分配计算错误: 总额 ${total} != ${expected}`);
}
return allocations;
}
}

298
backend/services/planting-service/src/infrastructure/external/authorization-service.client.ts vendored Normal file
View File

@ -0,0 +1,298 @@
import { Injectable, Logger } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { HttpService } from '@nestjs/axios';
import { firstValueFrom } from 'rxjs';
// 省市公司授权信息
export interface RegionAuthorization {
authorizationId: string;
userId: string;
roleType: string;
regionCode: string;
regionName: string;
benefitActive: boolean;
// 算力百分比（正式省公司 1%，正式市公司 2%）
hashpowerPercent: number;
}
// 社区授权信息
export interface CommunityAuthorization {
authorizationId: string;
userId: string;
communityName: string;
benefitActive: boolean;
}
// 系统账户信息
export interface SystemAccountInfo {
accountId: string;
accountType: string;
regionCode: string | null;
walletAddress: string | null;
}
// 分配上下文 - 包含授权查询结果
export interface AllocationContext {
// 省公司授权（区域权益 15U + 1% 算力）
provinceCompanyAuth: RegionAuthorization | null;
// 授权省公司（团队权益 20U）
authProvinceCompanyAuth: RegionAuthorization | null;
// 市公司授权（区域权益 35U + 2% 算力）
cityCompanyAuth: RegionAuthorization | null;
// 授权市公司（团队权益 40U）
authCityCompanyAuth: RegionAuthorization | null;
// 社区授权（80U）
communityAuth: CommunityAuthorization | null;
// 系统账户（用于无授权时的fallback）
systemAccounts: {
costAccount: SystemAccountInfo;
operationAccount: SystemAccountInfo;
hqCommunityAccount: SystemAccountInfo;
rwadPoolAccount: SystemAccountInfo;
systemProvinceAccount: SystemAccountInfo;
systemCityAccount: SystemAccountInfo;
};
}
@Injectable()
export class AuthorizationServiceClient {
private readonly logger = new Logger(AuthorizationServiceClient.name);
private readonly baseUrl: string;
constructor(
private readonly configService: ConfigService,
private readonly httpService: HttpService,
) {
this.baseUrl =
this.configService.get<string>('AUTHORIZATION_SERVICE_URL') ||
'http://localhost:3005';
}
/**
* 获取分配上下文 - 查询省市社区授权状态和系统账户
*/
async getAllocationContext(
planterId: string,
provinceCode: string,
cityCode: string,
): Promise<AllocationContext> {
try {
const response = await firstValueFrom(
this.httpService.get<AllocationContext>(
`${this.baseUrl}/api/v1/allocations/context`,
{
params: {
planterId,
provinceCode,
cityCode,
},
},
),
);
return response.data;
} catch (error) {
this.logger.error(
`Failed to get allocation context for planter ${planterId}`,
error,
);
// 开发环境返回默认数据
if (this.configService.get('NODE_ENV') === 'development') {
this.logger.warn(
'Development mode: returning default allocation context',
);
return this.getDefaultAllocationContext(provinceCode, cityCode);
}
throw error;
}
}
/**
* 获取省区域权益接收方
*/
async getProvinceAreaRightsRecipient(
provinceCode: string,
): Promise<{ recipientType: 'USER' | 'SYSTEM'; recipientId: string; hashpowerPercent: number }> {
try {
const response = await firstValueFrom(
this.httpService.get(
`${this.baseUrl}/api/v1/authorizations/province/${provinceCode}/area-rights`,
),
);
return response.data;
} catch (error) {
this.logger.error(`Failed to get province area rights recipient for ${provinceCode}`, error);
// 返回系统省账户作为默认
return {
recipientType: 'SYSTEM',
recipientId: `SYSTEM_PROVINCE:${provinceCode}`,
hashpowerPercent: 0,
};
}
}
/**
* 获取省团队权益接收方
*/
async getProvinceTeamRightsRecipient(
provinceCode: string,
): Promise<{ recipientType: 'USER' | 'SYSTEM'; recipientId: string }> {
try {
const response = await firstValueFrom(
this.httpService.get(
`${this.baseUrl}/api/v1/authorizations/province/${provinceCode}/team-rights`,
),
);
return response.data;
} catch (error) {
this.logger.error(`Failed to get province team rights recipient for ${provinceCode}`, error);
return {
recipientType: 'SYSTEM',
recipientId: `SYSTEM_PROVINCE:${provinceCode}`,
};
}
}
/**
* 获取市区域权益接收方
*/
async getCityAreaRightsRecipient(
cityCode: string,
): Promise<{ recipientType: 'USER' | 'SYSTEM'; recipientId: string; hashpowerPercent: number }> {
try {
const response = await firstValueFrom(
this.httpService.get(
`${this.baseUrl}/api/v1/authorizations/city/${cityCode}/area-rights`,
),
);
return response.data;
} catch (error) {
this.logger.error(`Failed to get city area rights recipient for ${cityCode}`, error);
return {
recipientType: 'SYSTEM',
recipientId: `SYSTEM_CITY:${cityCode}`,
hashpowerPercent: 0,
};
}
}
/**
* 获取市团队权益接收方
*/
async getCityTeamRightsRecipient(
cityCode: string,
): Promise<{ recipientType: 'USER' | 'SYSTEM'; recipientId: string }> {
try {
const response = await firstValueFrom(
this.httpService.get(
`${this.baseUrl}/api/v1/authorizations/city/${cityCode}/team-rights`,
),
);
return response.data;
} catch (error) {
this.logger.error(`Failed to get city team rights recipient for ${cityCode}`, error);
return {
recipientType: 'SYSTEM',
recipientId: `SYSTEM_CITY:${cityCode}`,
};
}
}
/**
* 获取社区权益接收方
*/
async getCommunityRightsRecipient(
planterId: string,
): Promise<{ recipientType: 'USER' | 'SYSTEM'; recipientId: string } | null> {
try {
const response = await firstValueFrom(
this.httpService.get(
`${this.baseUrl}/api/v1/authorizations/user/${planterId}/community-rights`,
),
);
return response.data;
} catch (error) {
this.logger.error(`Failed to get community rights recipient for ${planterId}`, error);
return null;
}
}
/**
* 通知认种完成，更新考核进度
*/
async notifyPlantingCompleted(params: {
planterId: string;
treeCount: number;
provinceCode: string;
cityCode: string;
orderId: string;
}): Promise<void> {
try {
await firstValueFrom(
this.httpService.post(
`${this.baseUrl}/api/v1/allocations/planting-completed`,
params,
),
);
} catch (error) {
this.logger.error('Failed to notify planting completed', error);
// 不抛出错误，允许继续执行
}
}
/**
* 获取默认分配上下文（开发环境用）
*/
private getDefaultAllocationContext(
provinceCode: string,
cityCode: string,
): AllocationContext {
return {
provinceCompanyAuth: null,
authProvinceCompanyAuth: null,
cityCompanyAuth: null,
authCityCompanyAuth: null,
communityAuth: null,
systemAccounts: {
costAccount: {
accountId: '1',
accountType: 'COST_ACCOUNT',
regionCode: null,
walletAddress: null,
},
operationAccount: {
accountId: '2',
accountType: 'OPERATION_ACCOUNT',
regionCode: null,
walletAddress: null,
},
hqCommunityAccount: {
accountId: '3',
accountType: 'HQ_COMMUNITY',
regionCode: null,
walletAddress: null,
},
rwadPoolAccount: {
accountId: '4',
accountType: 'RWAD_POOL_PENDING',
regionCode: null,
walletAddress: null,
},
systemProvinceAccount: {
accountId: `PROVINCE:${provinceCode}`,
accountType: 'SYSTEM_PROVINCE',
regionCode: provinceCode,
walletAddress: null,
},
systemCityAccount: {
accountId: `CITY:${cityCode}`,
accountType: 'SYSTEM_CITY',
regionCode: cityCode,
walletAddress: null,
},
},
};
}
}

1
backend/services/planting-service/src/infrastructure/external/index.ts vendored
View File

@ -1,2 +1,3 @@
export * from './wallet-service.client';
export * from './referral-service.client';
export * from './authorization-service.client';

6
backend/services/planting-service/src/infrastructure/infrastructure.module.ts
View File

@ -4,6 +4,7 @@ import { PrismaService } from './persistence/prisma/prisma.service';
import { PlantingOrderRepositoryImpl } from './persistence/repositories/planting-order.repository.impl';
import { PlantingPositionRepositoryImpl } from './persistence/repositories/planting-position.repository.impl';
import { PoolInjectionBatchRepositoryImpl } from './persistence/repositories/pool-injection-batch.repository.impl';
import { UnitOfWork, UNIT_OF_WORK } from './persistence/unit-of-work';
import { WalletServiceClient } from './external/wallet-service.client';
import { ReferralServiceClient } from './external/referral-service.client';
import { PLANTING_ORDER_REPOSITORY } from '../domain/repositories/planting-order.repository.interface';
@ -32,6 +33,10 @@ import { POOL_INJECTION_BATCH_REPOSITORY } from '../domain/repositories/pool-inj
provide: POOL_INJECTION_BATCH_REPOSITORY,
useClass: PoolInjectionBatchRepositoryImpl,
},
{
provide: UNIT_OF_WORK,
useClass: UnitOfWork,
},
WalletServiceClient,
ReferralServiceClient,
],
@ -40,6 +45,7 @@ import { POOL_INJECTION_BATCH_REPOSITORY } from '../domain/repositories/pool-inj
PLANTING_ORDER_REPOSITORY,
PLANTING_POSITION_REPOSITORY,
POOL_INJECTION_BATCH_REPOSITORY,
UNIT_OF_WORK,
WalletServiceClient,
ReferralServiceClient,
],

28
backend/services/planting-service/src/infrastructure/persistence/prisma/prisma.service.ts
View File

@ -1,5 +1,11 @@
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';
import { PrismaClient, Prisma } from '@prisma/client';
// 定义事务客户端类型
export type TransactionClient = Omit<
PrismaClient,
'$connect' | '$disconnect' | '$on' | '$transaction' | '$use' | '$extends'
>;
@Injectable()
export class PrismaService
@ -23,6 +29,26 @@ export class PrismaService
await this.$disconnect();
}
/**
* 执行数据库事务
* @param fn 事务回调函数
* @param options 事务选项
*/
async executeTransaction<T>(
fn: (tx: TransactionClient) => Promise<T>,
options?: {
maxWait?: number;
timeout?: number;
isolationLevel?: Prisma.TransactionIsolationLevel;
},
): Promise<T> {
return this.$transaction(fn, {
maxWait: options?.maxWait ?? 5000,
timeout: options?.timeout ?? 10000,
isolationLevel: options?.isolationLevel ?? Prisma.TransactionIsolationLevel.ReadCommitted,
});
}
async cleanDatabase() {
if (process.env.NODE_ENV !== 'test') {
throw new Error('cleanDatabase can only be used in test environment');

238
backend/services/planting-service/src/infrastructure/persistence/unit-of-work.ts Normal file
View File

@ -0,0 +1,238 @@
import { Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { PrismaService, TransactionClient } from './prisma/prisma.service';
import { PlantingOrder } from '../../domain/aggregates/planting-order.aggregate';
import { PlantingPosition } from '../../domain/aggregates/planting-position.aggregate';
import { PoolInjectionBatch } from '../../domain/aggregates/pool-injection-batch.aggregate';
import { PlantingOrderMapper } from './mappers/planting-order.mapper';
import { PlantingPositionMapper } from './mappers/planting-position.mapper';
import { PoolInjectionBatchMapper } from './mappers/pool-injection-batch.mapper';
/**
* 工作单元 - 用于管理跨多个聚合根的数据库事务
*
* 使用示例:
* ```typescript
* await this.unitOfWork.executeInTransaction(async (uow) => {
* await uow.saveOrder(order);
* await uow.savePosition(position);
* await uow.saveBatch(batch);
* });
* ```
*/
@Injectable()
export class UnitOfWork {
constructor(private readonly prisma: PrismaService) {}
/**
* 在数据库事务中执行操作
* 如果任何操作失败，所有变更都会回滚
*/
async executeInTransaction<T>(
fn: (uow: TransactionalUnitOfWork) => Promise<T>,
options?: {
maxWait?: number;
timeout?: number;
isolationLevel?: Prisma.TransactionIsolationLevel;
},
): Promise<T> {
return this.prisma.executeTransaction(async (tx) => {
const transactionalUow = new TransactionalUnitOfWork(tx);
return fn(transactionalUow);
}, options);
}
}
/**
* 事务性工作单元 - 在事务上下文中提供聚合根的持久化操作
*/
export class TransactionalUnitOfWork {
constructor(private readonly tx: TransactionClient) {}
/**
* 保存认种订单
*/
async saveOrder(order: PlantingOrder): Promise<void> {
const { orderData, allocations } = PlantingOrderMapper.toPersistence(order);
if (order.id) {
// 更新
await this.tx.plantingOrder.update({
where: { id: order.id },
data: {
status: orderData.status,
selectedProvince: orderData.selectedProvince,
selectedCity: orderData.selectedCity,
provinceCitySelectedAt: orderData.provinceCitySelectedAt,
provinceCityConfirmedAt: orderData.provinceCityConfirmedAt,
poolInjectionBatchId: orderData.poolInjectionBatchId,
poolInjectionScheduledTime: orderData.poolInjectionScheduledTime,
poolInjectionActualTime: orderData.poolInjectionActualTime,
poolInjectionTxHash: orderData.poolInjectionTxHash,
miningEnabledAt: orderData.miningEnabledAt,
paidAt: orderData.paidAt,
fundAllocatedAt: orderData.fundAllocatedAt,
},
});
// 如果有新的资金分配，插入
if (allocations.length > 0) {
const existingAllocations = await this.tx.fundAllocation.count({
where: { orderId: order.id },
});
if (existingAllocations === 0) {
await this.tx.fundAllocation.createMany({
data: allocations.map((a) => ({
orderId: order.id!,
targetType: a.targetType,
amount: a.amount,
targetAccountId: a.targetAccountId,
metadata: a.metadata ?? Prisma.DbNull,
})),
});
}
}
} else {
// 创建
const created = await this.tx.plantingOrder.create({
data: {
orderNo: orderData.orderNo,
userId: orderData.userId,
treeCount: orderData.treeCount,
totalAmount: orderData.totalAmount,
status: orderData.status,
selectedProvince: orderData.selectedProvince,
selectedCity: orderData.selectedCity,
provinceCitySelectedAt: orderData.provinceCitySelectedAt,
provinceCityConfirmedAt: orderData.provinceCityConfirmedAt,
poolInjectionBatchId: orderData.poolInjectionBatchId,
poolInjectionScheduledTime: orderData.poolInjectionScheduledTime,
poolInjectionActualTime: orderData.poolInjectionActualTime,
poolInjectionTxHash: orderData.poolInjectionTxHash,
miningEnabledAt: orderData.miningEnabledAt,
paidAt: orderData.paidAt,
fundAllocatedAt: orderData.fundAllocatedAt,
},
});
order.setId(created.id);
}
}
/**
* 保存用户持仓
*/
async savePosition(position: PlantingPosition): Promise<void> {
const { positionData } = PlantingPositionMapper.toPersistence(position);
if (position.id) {
// 更新
await this.tx.plantingPosition.update({
where: { id: position.id },
data: {
totalTreeCount: positionData.totalTreeCount,
effectiveTreeCount: positionData.effectiveTreeCount,
pendingTreeCount: positionData.pendingTreeCount,
firstMiningStartAt: positionData.firstMiningStartAt,
},
});
} else {
// 创建
const created = await this.tx.plantingPosition.create({
data: {
userId: positionData.userId,
totalTreeCount: positionData.totalTreeCount,
effectiveTreeCount: positionData.effectiveTreeCount,
pendingTreeCount: positionData.pendingTreeCount,
firstMiningStartAt: positionData.firstMiningStartAt,
},
});
position.setId(created.id);
}
}
/**
* 获取或创建用户持仓
*/
async getOrCreatePosition(userId: bigint): Promise<PlantingPosition> {
const existing = await this.tx.plantingPosition.findUnique({
where: { userId },
});
if (existing) {
return PlantingPositionMapper.toDomain(existing);
}
// 创建新的持仓
const position = PlantingPosition.create(userId);
await this.savePosition(position);
return position;
}
/**
* 保存底池注入批次
*/
async saveBatch(batch: PoolInjectionBatch): Promise<void> {
const data = PoolInjectionBatchMapper.toPersistence(batch);
if (batch.id) {
// 更新
await this.tx.poolInjectionBatch.update({
where: { id: batch.id },
data: {
status: data.status,
orderCount: data.orderCount,
totalAmount: data.totalAmount,
actualInjectionTime: data.actualInjectionTime,
injectionTxHash: data.injectionTxHash,
},
});
} else {
// 创建
const created = await this.tx.poolInjectionBatch.create({
data: {
batchNo: data.batchNo,
status: data.status,
startDate: data.startDate,
endDate: data.endDate,
orderCount: data.orderCount,
totalAmount: data.totalAmount,
scheduledInjectionTime: data.scheduledInjectionTime,
actualInjectionTime: data.actualInjectionTime,
injectionTxHash: data.injectionTxHash,
},
});
batch.setId(created.id);
}
}
/**
* 获取或创建当前批次
*/
async findOrCreateCurrentBatch(): Promise<PoolInjectionBatch> {
const now = new Date();
const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
const existing = await this.tx.poolInjectionBatch.findFirst({
where: {
startDate: { lte: now },
endDate: { gt: now },
status: 'PENDING',
},
});
if (existing) {
return PoolInjectionBatchMapper.toDomain(existing);
}
// 创建新批次 - PoolInjectionBatch.create 只需要 startDate，会自动计算 endDate
const batch = PoolInjectionBatch.create(startOfDay);
await this.saveBatch(batch);
return batch;
}
}
export const UNIT_OF_WORK = Symbol('UnitOfWork');

2
backend/services/referral-service/src/modules/api.module.ts
View File

@ -7,6 +7,7 @@ import {
TeamStatisticsController,
HealthController,
} from '../api';
import { InternalReferralController } from '../api/controllers/referral.controller';
@Module({
imports: [ConfigModule, ApplicationModule],
@ -15,6 +16,7 @@ import {
LeaderboardController,
TeamStatisticsController,
HealthController,
InternalReferralController,
],
})
export class ApiModule {}

34
backend/services/reward-service/src/infrastructure/external/authorization-service/authorization-service.client.ts vendored
View File

@ -67,4 +67,38 @@ export class AuthorizationServiceClient implements IAuthorizationServiceClient {
return null;
}
}
/**
* 通知过期奖励转入运营账户
* 根据文档：过期的直推奖励应转入运营账户
*/
async transferExpiredRewardToOperationAccount(params: {
amount: number;
sourceRewardId: bigint;
memo?: string;
}): Promise<void> {
try {
const response = await fetch(
`${this.baseUrl}/api/v1/system-accounts/receive-expired-reward`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
accountType: 'OPERATION_ACCOUNT',
amount: params.amount,
sourceRewardId: params.sourceRewardId.toString(),
memo: params.memo || '过期奖励转入',
}),
},
);
if (!response.ok) {
this.logger.warn(`Failed to transfer expired reward to operation account`);
}
} catch (error) {
this.logger.error(`Error transferring expired reward:`, error);
}
}
}

3
backend/services/wallet-service/package.json
View File

@ -45,7 +45,8 @@
"reflect-metadata": "^0.1.13",
"rxjs": "^7.8.1",
"uuid": "^9.0.0",
"ioredis": "^5.3.2"
"ioredis": "^5.3.2",
"kafkajs": "^2.2.4"
},
"devDependencies": {
"@nestjs/cli": "^10.0.0",

37
backend/services/wallet-service/prisma/schema.prisma
View File

@ -162,3 +162,40 @@ model SettlementOrder {
@@index([settleCurrency])
@@index([createdAt])
}
// ============================================
// 提现订单表
// ============================================
model WithdrawalOrder {
id BigInt @id @default(autoincrement()) @map("order_id")
orderNo String @unique @map("order_no") @db.VarChar(50)
accountSequence BigInt @map("account_sequence") // 跨服务关联标识
userId BigInt @map("user_id")
// 提现信息
amount Decimal @map("amount") @db.Decimal(20, 8) // 提现金额
fee Decimal @map("fee") @db.Decimal(20, 8) // 手续费
chainType String @map("chain_type") @db.VarChar(20) // 目标链 (BSC/KAVA)
toAddress String @map("to_address") @db.VarChar(100) // 提现目标地址
// 交易信息
txHash String? @map("tx_hash") @db.VarChar(100) // 链上交易哈希
// 状态
status String @default("PENDING") @map("status") @db.VarChar(20)
errorMessage String? @map("error_message") @db.VarChar(500)
// 时间戳
frozenAt DateTime? @map("frozen_at")
broadcastedAt DateTime? @map("broadcasted_at")
confirmedAt DateTime? @map("confirmed_at")
createdAt DateTime @default(now()) @map("created_at")
@@map("withdrawal_orders")
@@index([accountSequence])
@@index([userId])
@@index([status])
@@index([chainType])
@@index([txHash])
@@index([createdAt])
}

64
backend/services/wallet-service/src/api/controllers/internal-wallet.controller.ts Normal file
View File

@ -0,0 +1,64 @@
import { Controller, Get, Post, Body, Param } from '@nestjs/common';
import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';
import { WalletApplicationService } from '@/application/services';
import { GetMyWalletQuery } from '@/application/queries';
import { DeductForPlantingCommand, AllocateFundsCommand, FundAllocationItem } from '@/application/commands';
import { Public } from '@/shared/decorators';
/**
* 内部API控制器 - 供其他微服务调用
* 不需要JWT认证，通过内部网络访问
*/
@ApiTags('Internal Wallet API')
@Controller('wallets')
export class InternalWalletController {
constructor(private readonly walletService: WalletApplicationService) {}
@Get(':userId/balance')
@Public()
@ApiOperation({ summary: '获取用户钱包余额(内部API)' })
@ApiParam({ name: 'userId', description: '用户ID' })
@ApiResponse({ status: 200, description: '余额信息' })
async getBalance(@Param('userId') userId: string) {
const query = new GetMyWalletQuery(userId, userId);
const wallet = await this.walletService.getMyWallet(query);
return {
userId,
available: wallet.balances.usdt.available,
locked: wallet.balances.usdt.frozen,
currency: 'USDT',
};
}
@Post('deduct-for-planting')
@Public()
@ApiOperation({ summary: '认种扣款(内部API)' })
@ApiResponse({ status: 200, description: '扣款结果' })
async deductForPlanting(
@Body() dto: { userId: string; amount: number; orderId: string },
) {
const command = new DeductForPlantingCommand(
dto.userId,
dto.amount,
dto.orderId,
);
const success = await this.walletService.deductForPlanting(command);
return { success };
}
@Post('allocate-funds')
@Public()
@ApiOperation({ summary: '资金分配(内部API)' })
@ApiResponse({ status: 200, description: '分配结果' })
async allocateFunds(
@Body() dto: { orderId: string; allocations: FundAllocationItem[] },
) {
const command = new AllocateFundsCommand(
dto.orderId,
'', // payerUserId will be determined from order
dto.allocations,
);
const result = await this.walletService.allocateFunds(command);
return { success: result.success };
}
}

31
backend/services/wallet-service/src/api/controllers/wallet.controller.ts
View File

@ -2,11 +2,11 @@ import { Controller, Get, Post, Body, UseGuards } from '@nestjs/common';
import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse } from '@nestjs/swagger';
import { WalletApplicationService } from '@/application/services';
import { GetMyWalletQuery } from '@/application/queries';
import { ClaimRewardsCommand, SettleRewardsCommand } from '@/application/commands';
import { ClaimRewardsCommand, SettleRewardsCommand, RequestWithdrawalCommand } from '@/application/commands';
import { CurrentUser, CurrentUserPayload } from '@/shared/decorators';
import { JwtAuthGuard } from '@/shared/guards/jwt-auth.guard';
import { SettleRewardsDTO } from '@/api/dto/request';
import { WalletResponseDTO } from '@/api/dto/response';
import { SettleRewardsDTO, RequestWithdrawalDTO } from '@/api/dto/request';
import { WalletResponseDTO, WithdrawalResponseDTO, WithdrawalListItemDTO } from '@/api/dto/response';
@ApiTags('Wallet')
@Controller('wallet')
@ -50,4 +50,29 @@ export class WalletController {
const orderId = await this.walletService.settleRewards(command);
return { settlementOrderId: orderId };
}
@Post('withdraw')
@ApiOperation({ summary: '申请提现', description: '将USDT提现到指定地址' })
@ApiResponse({ status: 201, type: WithdrawalResponseDTO })
async requestWithdrawal(
@CurrentUser() user: CurrentUserPayload,
@Body() dto: RequestWithdrawalDTO,
): Promise<WithdrawalResponseDTO> {
const command = new RequestWithdrawalCommand(
user.userId,
dto.amount,
dto.toAddress,
dto.chainType,
);
return this.walletService.requestWithdrawal(command);
}
@Get('withdrawals')
@ApiOperation({ summary: '查询提现记录', description: '获取用户的提现订单列表' })
@ApiResponse({ status: 200, type: [WithdrawalListItemDTO] })
async getWithdrawals(
@CurrentUser() user: CurrentUserPayload,
): Promise<WithdrawalListItemDTO[]> {
return this.walletService.getWithdrawals(user.userId);
}
}

1
backend/services/wallet-service/src/api/dto/request/index.ts
View File

@ -1,3 +1,4 @@
export * from './deposit.dto';
export * from './ledger-query.dto';
export * from './settlement.dto';
export * from './withdrawal.dto';

26
backend/services/wallet-service/src/api/dto/request/withdrawal.dto.ts Normal file
View File

@ -0,0 +1,26 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsNumber, IsString, IsEnum, Min, Matches } from 'class-validator';
import { ChainType } from '@/domain/value-objects';
export class RequestWithdrawalDTO {
@ApiProperty({ description: '提现金额 (USDT)', example: 100 })
@IsNumber()
@Min(10, { message: '最小提现金额为 10 USDT' })
amount: number;
@ApiProperty({
description: '提现目标地址 (EVM地址)',
example: '0x1234567890abcdef1234567890abcdef12345678',
})
@IsString()
@Matches(/^0x[a-fA-F0-9]{40}$/, { message: '无效的EVM地址格式' })
toAddress: string;
@ApiProperty({
description: '目标链类型',
enum: ChainType,
example: 'BSC',
})
@IsEnum(ChainType)
chainType: ChainType;
}

1
backend/services/wallet-service/src/api/dto/response/index.ts
View File

@ -1,2 +1,3 @@
export * from './wallet.dto';
export * from './ledger.dto';
export * from './withdrawal.dto';

47
backend/services/wallet-service/src/api/dto/response/withdrawal.dto.ts Normal file
View File

@ -0,0 +1,47 @@
import { ApiProperty } from '@nestjs/swagger';
export class WithdrawalResponseDTO {
@ApiProperty({ description: '提现订单号', example: 'WD1234567890ABCD' })
orderNo: string;
@ApiProperty({ description: '提现金额', example: 100 })
amount: number;
@ApiProperty({ description: '手续费', example: 1 })
fee: number;
@ApiProperty({ description: '实际到账金额', example: 99 })
netAmount: number;
@ApiProperty({ description: '订单状态', example: 'FROZEN' })
status: string;
}
export class WithdrawalListItemDTO {
@ApiProperty({ description: '提现订单号', example: 'WD1234567890ABCD' })
orderNo: string;
@ApiProperty({ description: '提现金额', example: 100 })
amount: number;
@ApiProperty({ description: '手续费', example: 1 })
fee: number;
@ApiProperty({ description: '实际到账金额', example: 99 })
netAmount: number;
@ApiProperty({ description: '目标链', example: 'BSC' })
chainType: string;
@ApiProperty({ description: '提现地址', example: '0x1234...' })
toAddress: string;
@ApiProperty({ description: '链上交易哈希', nullable: true })
txHash: string | null;
@ApiProperty({ description: '订单状态', example: 'CONFIRMED' })
status: string;
@ApiProperty({ description: '创建时间' })
createdAt: string;
}

54
backend/services/wallet-service/src/application/commands/allocate-funds.command.ts Normal file
View File

@ -0,0 +1,54 @@
/**
* 资金分配命令 - 用于认种订单的资金分配
* 支持分配给用户钱包或系统账户
*/
export interface FundAllocationItem {
// 目标类型: USER 或 SYSTEM
targetType: 'USER' | 'SYSTEM';
// 目标ID: 用户ID 或 系统账户类型标识
targetId: string;
// 分配类型
allocationType: string;
// 金额 (USDT)
amount: number;
// 算力百分比（可选，仅省市公司区域权益有）
hashpowerPercent?: number;
// 元数据
metadata?: Record<string, any>;
}
export class AllocateFundsCommand {
constructor(
// 来源订单ID
public readonly orderId: string,
// 付款用户ID
public readonly payerUserId: string,
// 分配列表
public readonly allocations: FundAllocationItem[],
) {}
}
/**
* 批量链上转账命令
*/
export interface BatchTransferItem {
// 目标钱包地址
toAddress: string;
// 金额 (USDT)
amount: number;
// 分配类型标注
allocationType: string;
// 目标账户ID（用于记录）
targetAccountId?: string;
}
export class BatchOnChainTransferCommand {
constructor(
// 来源订单ID
public readonly orderId: string,
// 付款用户ID
public readonly payerUserId: string,
// 转账列表
public readonly transfers: BatchTransferItem[],
) {}
}

2
backend/services/wallet-service/src/application/commands/index.ts
View File

@ -3,3 +3,5 @@ export * from './deduct-for-planting.command';
export * from './add-rewards.command';
export * from './claim-rewards.command';
export * from './settle-rewards.command';
export * from './allocate-funds.command';
export * from './request-withdrawal.command';

25
backend/services/wallet-service/src/application/commands/request-withdrawal.command.ts Normal file
View File

@ -0,0 +1,25 @@
import { ChainType } from '@/domain/value-objects';
/**
* 请求提现命令
*/
export class RequestWithdrawalCommand {
constructor(
public readonly userId: string,
public readonly amount: number, // 提现金额 (USDT)
public readonly toAddress: string, // 目标地址
public readonly chainType: ChainType, // 目标链 (BSC/KAVA)
) {}
}
/**
* 更新提现状态命令 (内部使用)
*/
export class UpdateWithdrawalStatusCommand {
constructor(
public readonly orderNo: string,
public readonly status: 'BROADCASTED' | 'CONFIRMED' | 'FAILED',
public readonly txHash?: string,
public readonly errorMessage?: string,
) {}
}

367
backend/services/wallet-service/src/application/services/wallet-application.service.ts
View File

@ -1,21 +1,25 @@
import { Injectable, Inject, Logger } from '@nestjs/common';
import { Injectable, Inject, Logger, BadRequestException } from '@nestjs/common';
import {
IWalletAccountRepository, WALLET_ACCOUNT_REPOSITORY,
ILedgerEntryRepository, LEDGER_ENTRY_REPOSITORY,
IDepositOrderRepository, DEPOSIT_ORDER_REPOSITORY,
ISettlementOrderRepository, SETTLEMENT_ORDER_REPOSITORY,
IWithdrawalOrderRepository, WITHDRAWAL_ORDER_REPOSITORY,
} from '@/domain/repositories';
import { LedgerEntry, DepositOrder, SettlementOrder } from '@/domain/aggregates';
import { LedgerEntry, DepositOrder, SettlementOrder, WithdrawalOrder } from '@/domain/aggregates';
import {
UserId, Money, Hashpower, LedgerEntryType, AssetType, ChainType, SettleCurrency,
} from '@/domain/value-objects';
import {
HandleDepositCommand, DeductForPlantingCommand, AddRewardsCommand,
ClaimRewardsCommand, SettleRewardsCommand,
ClaimRewardsCommand, SettleRewardsCommand, AllocateFundsCommand, FundAllocationItem,
RequestWithdrawalCommand, UpdateWithdrawalStatusCommand,
} from '@/application/commands';
import { GetMyWalletQuery, GetMyLedgerQuery } from '@/application/queries';
import { DuplicateTransactionError, WalletNotFoundError } from '@/shared/exceptions/domain.exception';
import { WalletCacheService } from '@/infrastructure/redis';
import { EventPublisherService } from '@/infrastructure/kafka';
import { WithdrawalRequestedEvent } from '@/domain/events';
export interface WalletDTO {
walletId: string;
@ -75,7 +79,10 @@ export class WalletApplicationService {
private readonly depositRepo: IDepositOrderRepository,
@Inject(SETTLEMENT_ORDER_REPOSITORY)
private readonly settlementRepo: ISettlementOrderRepository,
@Inject(WITHDRAWAL_ORDER_REPOSITORY)
private readonly withdrawalRepo: IWithdrawalOrderRepository,
private readonly walletCacheService: WalletCacheService,
private readonly eventPublisher: EventPublisherService,
) {}
// =============== Commands ===============
@ -129,7 +136,7 @@ export class WalletApplicationService {
await this.walletCacheService.invalidateWallet(userId);
}
async deductForPlanting(command: DeductForPlantingCommand): Promise<void> {
async deductForPlanting(command: DeductForPlantingCommand): Promise<boolean> {
const userId = BigInt(command.userId);
const amount = Money.USDT(command.amount);
@ -148,7 +155,7 @@ export class WalletApplicationService {
userId: UserId.create(userId),
entryType: LedgerEntryType.PLANT_PAYMENT,
amount: Money.signed(-command.amount, 'USDT'), // Negative for deduction
balanceAfter: wallet.balances.usdt.available,
balanceAfter: Money.USDT(wallet.balances.usdt.available.value), // Use value to create new Money
refOrderId: command.orderId,
memo: 'Plant payment',
});
@ -156,6 +163,7 @@ export class WalletApplicationService {
// Invalidate wallet cache after deduction
await this.walletCacheService.invalidateWallet(userId);
return true;
}
async addRewards(command: AddRewardsCommand): Promise<void> {
@ -301,6 +309,355 @@ export class WalletApplicationService {
return savedOrder.id.toString();
}
/**
* 分配资金 - 用于认种订单支付后的资金分配
* 支持分配给用户钱包或系统账户
*/
async allocateFunds(command: AllocateFundsCommand): Promise<{
success: boolean;
allocatedCount: number;
totalAmount: number;
}> {
this.logger.log(`Allocating funds for order ${command.orderId}`);
let totalAmount = 0;
let allocatedCount = 0;
for (const allocation of command.allocations) {
try {
if (allocation.targetType === 'USER') {
// 分配给用户钱包
await this.allocateToUserWallet(allocation, command.orderId);
} else {
// 分配给系统账户 - 通过 Kafka 事件通知 authorization-service
await this.allocateToSystemAccount(allocation, command.orderId);
}
totalAmount += allocation.amount;
allocatedCount++;
} catch (error) {
this.logger.error(
`Failed to allocate ${allocation.allocationType} to ${allocation.targetId}`,
error,
);
}
}
this.logger.log(
`Allocated ${allocatedCount}/${command.allocations.length} items, total ${totalAmount} USDT`,
);
return {
success: allocatedCount > 0,
allocatedCount,
totalAmount,
};
}
/**
* 分配资金到用户钱包
*/
private async allocateToUserWallet(
allocation: FundAllocationItem,
orderId: string,
): Promise<void> {
const userId = BigInt(allocation.targetId);
const wallet = await this.walletRepo.findByUserId(userId);
if (!wallet) {
this.logger.warn(`Wallet not found for user ${allocation.targetId}, skipping allocation`);
return;
}
const amount = Money.USDT(allocation.amount);
// 添加待领取奖励（24小时后过期）
const expireAt = new Date(Date.now() + 24 * 60 * 60 * 1000);
wallet.addPendingReward(
amount,
Hashpower.create(0),
expireAt,
orderId,
);
await this.walletRepo.save(wallet);
// 记录流水
const ledgerEntry = LedgerEntry.create({
accountSequence: wallet.accountSequence,
userId: UserId.create(userId),
entryType: LedgerEntryType.REWARD_PENDING,
amount,
refOrderId: orderId,
memo: `${allocation.allocationType} allocation`,
payloadJson: {
allocationType: allocation.allocationType,
expireAt: expireAt.toISOString(),
metadata: allocation.metadata,
},
});
await this.ledgerRepo.save(ledgerEntry);
await this.walletCacheService.invalidateWallet(userId);
this.logger.debug(
`Allocated ${allocation.amount} USDT to user ${allocation.targetId} for ${allocation.allocationType}`,
);
}
/**
* 分配资金到系统账户
* 通过记录流水，实际资金转移由 authorization-service 处理
*/
private async allocateToSystemAccount(
allocation: FundAllocationItem,
orderId: string,
): Promise<void> {
// 记录系统账户分配流水（用于审计和对账）
// 系统账户不通过 wallet-service 管理余额，而是发送事件通知 authorization-service
this.logger.debug(
`System account allocation: ${allocation.amount} USDT to ${allocation.targetId} for ${allocation.allocationType}`,
);
// TODO: 发布 Kafka 事件通知 authorization-service 更新系统账户余额
// await this.eventPublisher.publish('system-account.funds-allocated', {
// targetAccountType: allocation.targetId,
// amount: allocation.amount,
// allocationType: allocation.allocationType,
// sourceOrderId: orderId,
// hashpowerPercent: allocation.hashpowerPercent,
// metadata: allocation.metadata,
// });
}
// =============== Withdrawal ===============
/**
* 提现手续费 (固定费用，可配置)
*/
private readonly WITHDRAWAL_FEE = 1; // 1 USDT
/**
* 最小提现金额
*/
private readonly MIN_WITHDRAWAL_AMOUNT = 10; // 10 USDT
/**
* 请求提现
*
* 流程:
* 1. 验证余额是否足够 (金额 + 手续费)
* 2. 创建提现订单
* 3. 冻结用户余额
* 4. 记录流水
* 5. 发布事件通知 blockchain-service
*/
async requestWithdrawal(command: RequestWithdrawalCommand): Promise<{
orderNo: string;
amount: number;
fee: number;
netAmount: number;
status: string;
}> {
const userId = BigInt(command.userId);
const amount = Money.USDT(command.amount);
const fee = Money.USDT(this.WITHDRAWAL_FEE);
const totalRequired = amount.add(fee);
this.logger.log(`Processing withdrawal request for user ${userId}: ${command.amount} USDT to ${command.toAddress}`);
// 验证最小提现金额
if (command.amount < this.MIN_WITHDRAWAL_AMOUNT) {
throw new Error(`最小提现金额为 ${this.MIN_WITHDRAWAL_AMOUNT} USDT`);
}
// 获取钱包
const wallet = await this.walletRepo.findByUserId(userId);
if (!wallet) {
throw new WalletNotFoundError(`userId: ${command.userId}`);
}
// 验证余额是否足够
if (wallet.balances.usdt.available.lessThan(totalRequired)) {
throw new BadRequestException(
`余额不足: 需要 ${totalRequired.value} USDT (金额 ${command.amount} + 手续费 ${this.WITHDRAWAL_FEE}), 当前可用 ${wallet.balances.usdt.available.value} USDT`,
);
}
// 创建提现订单
const withdrawalOrder = WithdrawalOrder.create({
accountSequence: wallet.accountSequence,
userId: UserId.create(userId),
amount,
fee,
chainType: command.chainType,
toAddress: command.toAddress,
});
// 冻结用户余额 (金额 + 手续费)
wallet.freeze(totalRequired);
await this.walletRepo.save(wallet);
// 标记订单已冻结
withdrawalOrder.markAsFrozen();
const savedOrder = await this.withdrawalRepo.save(withdrawalOrder);
// 记录流水 - 冻结
const freezeEntry = LedgerEntry.create({
accountSequence: wallet.accountSequence,
userId: UserId.create(userId),
entryType: LedgerEntryType.FREEZE,
amount: Money.signed(-totalRequired.value, 'USDT'),
balanceAfter: wallet.balances.usdt.available,
refOrderId: savedOrder.orderNo,
memo: `Withdrawal freeze: ${command.amount} USDT + ${this.WITHDRAWAL_FEE} USDT fee`,
});
await this.ledgerRepo.save(freezeEntry);
// 发布事件通知 blockchain-service
const event = new WithdrawalRequestedEvent({
orderNo: savedOrder.orderNo,
accountSequence: wallet.accountSequence.toString(),
userId: userId.toString(),
walletId: wallet.walletId.toString(),
amount: command.amount.toString(),
fee: this.WITHDRAWAL_FEE.toString(),
netAmount: (command.amount - this.WITHDRAWAL_FEE).toString(),
assetType: 'USDT',
chainType: command.chainType,
toAddress: command.toAddress,
});
// 发布到 Kafka 通知 blockchain-service
await this.eventPublisher.publish({
eventType: 'wallet.withdrawal.requested',
payload: event.getPayload() as unknown as { [key: string]: unknown },
});
this.logger.log(`Withdrawal event published: ${savedOrder.orderNo}`);
// 清除钱包缓存
await this.walletCacheService.invalidateWallet(userId);
this.logger.log(`Withdrawal order created: ${savedOrder.orderNo}`);
return {
orderNo: savedOrder.orderNo,
amount: savedOrder.amount.value,
fee: savedOrder.fee.value,
netAmount: savedOrder.netAmount.value,
status: savedOrder.status,
};
}
/**
* 更新提现状态 (内部调用，由 blockchain-service 事件触发)
*/
async updateWithdrawalStatus(command: UpdateWithdrawalStatusCommand): Promise<void> {
this.logger.log(`Updating withdrawal ${command.orderNo} to status ${command.status}`);
const order = await this.withdrawalRepo.findByOrderNo(command.orderNo);
if (!order) {
throw new Error(`Withdrawal order not found: ${command.orderNo}`);
}
const wallet = await this.walletRepo.findByUserId(order.userId.value);
if (!wallet) {
throw new WalletNotFoundError(`userId: ${order.userId.value}`);
}
const totalFrozen = order.amount.add(order.fee);
switch (command.status) {
case 'BROADCASTED':
if (!command.txHash) {
throw new Error('txHash is required for BROADCASTED status');
}
order.markAsBroadcasted(command.txHash);
await this.withdrawalRepo.save(order);
break;
case 'CONFIRMED':
order.markAsConfirmed();
await this.withdrawalRepo.save(order);
// 解冻并扣除
wallet.unfreeze(totalFrozen);
wallet.deduct(totalFrozen, 'Withdrawal completed', order.orderNo);
await this.walletRepo.save(wallet);
// 记录提现完成流水
const withdrawEntry = LedgerEntry.create({
accountSequence: wallet.accountSequence,
userId: order.userId,
entryType: LedgerEntryType.WITHDRAWAL,
amount: Money.signed(-order.amount.value, 'USDT'),
balanceAfter: wallet.balances.usdt.available,
refOrderId: order.orderNo,
refTxHash: order.txHash ?? undefined,
memo: `Withdrawal to ${order.toAddress}`,
});
await this.ledgerRepo.save(withdrawEntry);
this.logger.log(`Withdrawal ${order.orderNo} confirmed, txHash: ${order.txHash}`);
break;
case 'FAILED':
order.markAsFailed(command.errorMessage || 'Unknown error');
await this.withdrawalRepo.save(order);
// 解冻资金
if (order.needsUnfreeze()) {
wallet.unfreeze(totalFrozen);
await this.walletRepo.save(wallet);
// 记录解冻流水
const unfreezeEntry = LedgerEntry.create({
accountSequence: wallet.accountSequence,
userId: order.userId,
entryType: LedgerEntryType.UNFREEZE,
amount: totalFrozen,
balanceAfter: wallet.balances.usdt.available,
refOrderId: order.orderNo,
memo: `Withdrawal failed, funds unfrozen: ${command.errorMessage}`,
});
await this.ledgerRepo.save(unfreezeEntry);
}
this.logger.warn(`Withdrawal ${order.orderNo} failed: ${command.errorMessage}`);
break;
}
await this.walletCacheService.invalidateWallet(order.userId.value);
}
/**
* 查询用户提现订单
*/
async getWithdrawals(userId: string): Promise<Array<{
orderNo: string;
amount: number;
fee: number;
netAmount: number;
chainType: string;
toAddress: string;
txHash: string | null;
status: string;
createdAt: string;
}>> {
const orders = await this.withdrawalRepo.findByUserId(BigInt(userId));
return orders.map(order => ({
orderNo: order.orderNo,
amount: order.amount.value,
fee: order.fee.value,
netAmount: order.netAmount.value,
chainType: order.chainType,
toAddress: order.toAddress,
txHash: order.txHash,
status: order.status,
createdAt: order.createdAt.toISOString(),
}));
}
// =============== Queries ===============
async getMyWallet(query: GetMyWalletQuery): Promise<WalletDTO> {

1
backend/services/wallet-service/src/domain/aggregates/index.ts
View File

@ -2,3 +2,4 @@ export * from './wallet-account.aggregate';
export * from './ledger-entry.aggregate';
export * from './deposit-order.aggregate';
export * from './settlement-order.aggregate';
export * from './withdrawal-order.aggregate';

2
backend/services/wallet-service/src/domain/aggregates/ledger-entry.aggregate.ts
View File

@ -99,7 +99,7 @@ export class LedgerEntry {
params.accountSequence,
UserId.create(params.userId),
params.entryType as LedgerEntryType,
Money.create(params.amount, params.assetType),
Money.signed(params.amount, params.assetType), // Use signed() to allow negative amounts for deductions
params.balanceAfter ? Money.create(params.balanceAfter, params.assetType) : null,
params.refOrderId,
params.refTxHash,

258
backend/services/wallet-service/src/domain/aggregates/withdrawal-order.aggregate.ts Normal file
View File

@ -0,0 +1,258 @@
import Decimal from 'decimal.js';
import { UserId, ChainType, AssetType, Money } from '@/domain/value-objects';
import { WithdrawalStatus } from '@/domain/value-objects/withdrawal-status.enum';
import { DomainError } from '@/shared/exceptions/domain.exception';
/**
* 提现订单聚合根
*
* 提现流程:
* 1. 用户发起提现请求 -> PENDING
* 2. 冻结用户余额 -> FROZEN
* 3. blockchain-service 签名并广播 -> BROADCASTED
* 4. 链上确认 -> CONFIRMED
*
* 失败/取消时解冻资金
*/
export class WithdrawalOrder {
private readonly _id: bigint;
private readonly _orderNo: string;
private readonly _accountSequence: bigint;
private readonly _userId: UserId;
private readonly _amount: Money;
private readonly _fee: Money; // 手续费
private readonly _chainType: ChainType;
private readonly _toAddress: string; // 提现目标地址
private _txHash: string | null;
private _status: WithdrawalStatus;
private _errorMessage: string | null;
private _frozenAt: Date | null;
private _broadcastedAt: Date | null;
private _confirmedAt: Date | null;
private readonly _createdAt: Date;
private constructor(
id: bigint,
orderNo: string,
accountSequence: bigint,
userId: UserId,
amount: Money,
fee: Money,
chainType: ChainType,
toAddress: string,
txHash: string | null,
status: WithdrawalStatus,
errorMessage: string | null,
frozenAt: Date | null,
broadcastedAt: Date | null,
confirmedAt: Date | null,
createdAt: Date,
) {
this._id = id;
this._orderNo = orderNo;
this._accountSequence = accountSequence;
this._userId = userId;
this._amount = amount;
this._fee = fee;
this._chainType = chainType;
this._toAddress = toAddress;
this._txHash = txHash;
this._status = status;
this._errorMessage = errorMessage;
this._frozenAt = frozenAt;
this._broadcastedAt = broadcastedAt;
this._confirmedAt = confirmedAt;
this._createdAt = createdAt;
}
// Getters
get id(): bigint { return this._id; }
get orderNo(): string { return this._orderNo; }
get accountSequence(): bigint { return this._accountSequence; }
get userId(): UserId { return this._userId; }
get amount(): Money { return this._amount; }
get fee(): Money { return this._fee; }
get netAmount(): Money { return Money.USDT(this._amount.value - this._fee.value); }
get chainType(): ChainType { return this._chainType; }
get toAddress(): string { return this._toAddress; }
get txHash(): string | null { return this._txHash; }
get status(): WithdrawalStatus { return this._status; }
get errorMessage(): string | null { return this._errorMessage; }
get frozenAt(): Date | null { return this._frozenAt; }
get broadcastedAt(): Date | null { return this._broadcastedAt; }
get confirmedAt(): Date | null { return this._confirmedAt; }
get createdAt(): Date { return this._createdAt; }
get isPending(): boolean { return this._status === WithdrawalStatus.PENDING; }
get isFrozen(): boolean { return this._status === WithdrawalStatus.FROZEN; }
get isBroadcasted(): boolean { return this._status === WithdrawalStatus.BROADCASTED; }
get isConfirmed(): boolean { return this._status === WithdrawalStatus.CONFIRMED; }
get isFailed(): boolean { return this._status === WithdrawalStatus.FAILED; }
get isCancelled(): boolean { return this._status === WithdrawalStatus.CANCELLED; }
get isFinished(): boolean {
return this._status === WithdrawalStatus.CONFIRMED ||
this._status === WithdrawalStatus.FAILED ||
this._status === WithdrawalStatus.CANCELLED;
}
/**
* 生成提现订单号
*/
private static generateOrderNo(): string {
const timestamp = Date.now();
const random = Math.random().toString(36).substring(2, 8).toUpperCase();
return `WD${timestamp}${random}`;
}
/**
* 创建提现订单
*/
static create(params: {
accountSequence: bigint;
userId: UserId;
amount: Money;
fee: Money;
chainType: ChainType;
toAddress: string;
}): WithdrawalOrder {
// 验证金额
if (params.amount.value <= 0) {
throw new DomainError('Withdrawal amount must be positive');
}
// 验证手续费
if (params.fee.value < 0) {
throw new DomainError('Withdrawal fee cannot be negative');
}
// 验证净额大于0
if (params.amount.value <= params.fee.value) {
throw new DomainError('Withdrawal amount must be greater than fee');
}
// 验证地址格式 (简单的EVM地址检查)
if (!params.toAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
throw new DomainError('Invalid withdrawal address format');
}
return new WithdrawalOrder(
BigInt(0), // Will be set by database
this.generateOrderNo(),
params.accountSequence,
params.userId,
params.amount,
params.fee,
params.chainType,
params.toAddress,
null,
WithdrawalStatus.PENDING,
null,
null,
null,
null,
new Date(),
);
}
/**
* 从数据库重建
*/
static reconstruct(params: {
id: bigint;
orderNo: string;
accountSequence: bigint;
userId: bigint;
amount: Decimal;
fee: Decimal;
chainType: string;
toAddress: string;
txHash: string | null;
status: string;
errorMessage: string | null;
frozenAt: Date | null;
broadcastedAt: Date | null;
confirmedAt: Date | null;
createdAt: Date;
}): WithdrawalOrder {
return new WithdrawalOrder(
params.id,
params.orderNo,
params.accountSequence,
UserId.create(params.userId),
Money.USDT(params.amount),
Money.USDT(params.fee),
params.chainType as ChainType,
params.toAddress,
params.txHash,
params.status as WithdrawalStatus,
params.errorMessage,
params.frozenAt,
params.broadcastedAt,
params.confirmedAt,
params.createdAt,
);
}
/**
* 标记为已冻结 (资金已从可用余额冻结)
*/
markAsFrozen(): void {
if (this._status !== WithdrawalStatus.PENDING) {
throw new DomainError('Only pending withdrawals can be frozen');
}
this._status = WithdrawalStatus.FROZEN;
this._frozenAt = new Date();
}
/**
* 标记为已广播
*/
markAsBroadcasted(txHash: string): void {
if (this._status !== WithdrawalStatus.FROZEN) {
throw new DomainError('Only frozen withdrawals can be broadcasted');
}
this._status = WithdrawalStatus.BROADCASTED;
this._txHash = txHash;
this._broadcastedAt = new Date();
}
/**
* 标记为已确认 (链上确认)
*/
markAsConfirmed(): void {
if (this._status !== WithdrawalStatus.BROADCASTED) {
throw new DomainError('Only broadcasted withdrawals can be confirmed');
}
this._status = WithdrawalStatus.CONFIRMED;
this._confirmedAt = new Date();
}
/**
* 标记为失败
*/
markAsFailed(errorMessage: string): void {
if (this.isFinished) {
throw new DomainError('Cannot fail a finished withdrawal');
}
this._status = WithdrawalStatus.FAILED;
this._errorMessage = errorMessage;
}
/**
* 取消提现
*/
cancel(): void {
if (this._status !== WithdrawalStatus.PENDING && this._status !== WithdrawalStatus.FROZEN) {
throw new DomainError('Only pending or frozen withdrawals can be cancelled');
}
this._status = WithdrawalStatus.CANCELLED;
}
/**
* 是否需要解冻资金 (失败或取消且已冻结)
*/
needsUnfreeze(): boolean {
return (this._status === WithdrawalStatus.FAILED || this._status === WithdrawalStatus.CANCELLED)
&& this._frozenAt !== null;
}
}

17
backend/services/wallet-service/src/domain/events/withdrawal-requested.event.ts
View File

@ -1,18 +1,25 @@
import { DomainEvent } from './domain-event.base';
export interface WithdrawalRequestedPayload {
orderNo: string; // 提现订单号
accountSequence: string; // 跨服务关联标识
userId: string;
walletId: string;
amount: string;
assetType: string;
toAddress: string;
amount: string; // 提现金额
fee: string; // 手续费
netAmount: string; // 实际到账金额 (amount - fee)
assetType: string; // 资产类型 (USDT)
chainType: string; // 目标链 (BSC/KAVA)
toAddress: string; // 提现目标地址
}
export class WithdrawalRequestedEvent extends DomainEvent {
static readonly EVENT_NAME = 'wallet.withdrawal.requested';
constructor(private readonly payload: WithdrawalRequestedPayload) {
super({
aggregateId: payload.walletId,
aggregateType: 'WalletAccount',
aggregateId: payload.orderNo,
aggregateType: 'WithdrawalOrder',
});
}

1
backend/services/wallet-service/src/domain/repositories/index.ts
View File

@ -2,3 +2,4 @@ export * from './wallet-account.repository.interface';
export * from './ledger-entry.repository.interface';
export * from './deposit-order.repository.interface';
export * from './settlement-order.repository.interface';
export * from './withdrawal-order.repository.interface';

14
backend/services/wallet-service/src/domain/repositories/withdrawal-order.repository.interface.ts Normal file
View File

@ -0,0 +1,14 @@
import { WithdrawalOrder } from '@/domain/aggregates';
import { WithdrawalStatus } from '@/domain/value-objects';
export interface IWithdrawalOrderRepository {
save(order: WithdrawalOrder): Promise<WithdrawalOrder>;
findById(orderId: bigint): Promise<WithdrawalOrder | null>;
findByOrderNo(orderNo: string): Promise<WithdrawalOrder | null>;
findByUserId(userId: bigint, status?: WithdrawalStatus): Promise<WithdrawalOrder[]>;
findPendingOrders(): Promise<WithdrawalOrder[]>;
findFrozenOrders(): Promise<WithdrawalOrder[]>;
findBroadcastedOrders(): Promise<WithdrawalOrder[]>;
}
export const WITHDRAWAL_ORDER_REPOSITORY = Symbol('IWithdrawalOrderRepository');

1
backend/services/wallet-service/src/domain/value-objects/index.ts
View File

@ -4,6 +4,7 @@ export * from './wallet-status.enum';
export * from './ledger-entry-type.enum';
export * from './deposit-status.enum';
export * from './settlement-status.enum';
export * from './withdrawal-status.enum';
export * from './money.vo';
export * from './balance.vo';
export * from './hashpower.vo';

8
backend/services/wallet-service/src/domain/value-objects/withdrawal-status.enum.ts Normal file
View File

@ -0,0 +1,8 @@
export enum WithdrawalStatus {
PENDING = 'PENDING', // 待处理
FROZEN = 'FROZEN', // 已冻结资金，等待签名
BROADCASTED = 'BROADCASTED', // 已广播到链上
CONFIRMED = 'CONFIRMED', // 链上确认完成
FAILED = 'FAILED', // 失败
CANCELLED = 'CANCELLED', // 已取消
}

11
backend/services/wallet-service/src/infrastructure/infrastructure.module.ts
View File

@ -5,14 +5,17 @@ import {
LedgerEntryRepositoryImpl,
DepositOrderRepositoryImpl,
SettlementOrderRepositoryImpl,
WithdrawalOrderRepositoryImpl,
} from './persistence/repositories';
import {
WALLET_ACCOUNT_REPOSITORY,
LEDGER_ENTRY_REPOSITORY,
DEPOSIT_ORDER_REPOSITORY,
SETTLEMENT_ORDER_REPOSITORY,
WITHDRAWAL_ORDER_REPOSITORY,
} from '@/domain/repositories';
import { RedisModule } from './redis';
import { KafkaModule } from './kafka';
const repositories = [
{
@ -31,12 +34,16 @@ const repositories = [
provide: SETTLEMENT_ORDER_REPOSITORY,
useClass: SettlementOrderRepositoryImpl,
},
{
provide: WITHDRAWAL_ORDER_REPOSITORY,
useClass: WithdrawalOrderRepositoryImpl,
},
];
@Global()
@Module({
imports: [RedisModule],
imports: [RedisModule, KafkaModule],
providers: [PrismaService, ...repositories],
exports: [PrismaService, RedisModule, ...repositories],
exports: [PrismaService, RedisModule, KafkaModule, ...repositories],
})
export class InfrastructureModule {}

1
backend/services/wallet-service/src/infrastructure/persistence/repositories/index.ts
View File

@ -2,3 +2,4 @@ export * from './wallet-account.repository.impl';
export * from './ledger-entry.repository.impl';
export * from './deposit-order.repository.impl';
export * from './settlement-order.repository.impl';
export * from './withdrawal-order.repository.impl';

127
backend/services/wallet-service/src/infrastructure/persistence/repositories/withdrawal-order.repository.impl.ts Normal file
View File

@ -0,0 +1,127 @@
import { Injectable } from '@nestjs/common';
import { PrismaService } from '@/infrastructure/persistence/prisma/prisma.service';
import { IWithdrawalOrderRepository } from '@/domain/repositories';
import { WithdrawalOrder } from '@/domain/aggregates';
import { WithdrawalStatus } from '@/domain/value-objects';
import Decimal from 'decimal.js';
@Injectable()
export class WithdrawalOrderRepositoryImpl implements IWithdrawalOrderRepository {
constructor(private readonly prisma: PrismaService) {}
async save(order: WithdrawalOrder): Promise<WithdrawalOrder> {
const data = {
orderNo: order.orderNo,
accountSequence: order.accountSequence,
userId: order.userId.value,
amount: order.amount.toDecimal(),
fee: order.fee.toDecimal(),
chainType: order.chainType,
toAddress: order.toAddress,
txHash: order.txHash,
status: order.status,
errorMessage: order.errorMessage,
frozenAt: order.frozenAt,
broadcastedAt: order.broadcastedAt,
confirmedAt: order.confirmedAt,
};
if (order.id === BigInt(0)) {
const created = await this.prisma.withdrawalOrder.create({ data });
return this.toDomain(created);
} else {
const updated = await this.prisma.withdrawalOrder.update({
where: { id: order.id },
data,
});
return this.toDomain(updated);
}
}
async findById(orderId: bigint): Promise<WithdrawalOrder | null> {
const record = await this.prisma.withdrawalOrder.findUnique({
where: { id: orderId },
});
return record ? this.toDomain(record) : null;
}
async findByOrderNo(orderNo: string): Promise<WithdrawalOrder | null> {
const record = await this.prisma.withdrawalOrder.findUnique({
where: { orderNo },
});
return record ? this.toDomain(record) : null;
}
async findByUserId(userId: bigint, status?: WithdrawalStatus): Promise<WithdrawalOrder[]> {
const where: Record<string, unknown> = { userId };
if (status) {
where.status = status;
}
const records = await this.prisma.withdrawalOrder.findMany({
where,
orderBy: { createdAt: 'desc' },
});
return records.map(r => this.toDomain(r));
}
async findPendingOrders(): Promise<WithdrawalOrder[]> {
const records = await this.prisma.withdrawalOrder.findMany({
where: { status: WithdrawalStatus.PENDING },
orderBy: { createdAt: 'asc' },
});
return records.map(r => this.toDomain(r));
}
async findFrozenOrders(): Promise<WithdrawalOrder[]> {
const records = await this.prisma.withdrawalOrder.findMany({
where: { status: WithdrawalStatus.FROZEN },
orderBy: { createdAt: 'asc' },
});
return records.map(r => this.toDomain(r));
}
async findBroadcastedOrders(): Promise<WithdrawalOrder[]> {
const records = await this.prisma.withdrawalOrder.findMany({
where: { status: WithdrawalStatus.BROADCASTED },
orderBy: { createdAt: 'asc' },
});
return records.map(r => this.toDomain(r));
}
private toDomain(record: {
id: bigint;
orderNo: string;
accountSequence: bigint;
userId: bigint;
amount: Decimal;
fee: Decimal;
chainType: string;
toAddress: string;
txHash: string | null;
status: string;
errorMessage: string | null;
frozenAt: Date | null;
broadcastedAt: Date | null;
confirmedAt: Date | null;
createdAt: Date;
}): WithdrawalOrder {
return WithdrawalOrder.reconstruct({
id: record.id,
orderNo: record.orderNo,
accountSequence: record.accountSequence,
userId: record.userId,
amount: new Decimal(record.amount.toString()),
fee: new Decimal(record.fee.toString()),
chainType: record.chainType,
toAddress: record.toAddress,
txHash: record.txHash,
status: record.status,
errorMessage: record.errorMessage,
frozenAt: record.frozenAt,
broadcastedAt: record.broadcastedAt,
confirmedAt: record.confirmedAt,
createdAt: record.createdAt,
});
}
}